How to serialize / deserialize a cyclic graph where each node gets to
define a special (de)serialization function.

Re: chefs, recipies, etc... from E.

Object toSerializeMe()  returns an object which holds all of the state
I care about serializing.  Most objects just return themselves.

The serializer has to notice any objects which return a different
value (from themselves) from this function.  Such objects must be
saved in a table, and any later references to them (including inside
the returned object) are replaced with the returned object.

This much shouldn't be a problem.  It's the deserialization that's
hard.  

void initializeFromSerialization(Object)  is the inverse of
toSerializeMe, but it requires the deserializer to have access to a
no-argument constructor.  Furthermore, this method has access to
potentially uninitialized objects via the initialization object.

Create the inverse table to the one created above, and scan the whole
deserialized object graph for table entries which then get substituted
back.  Problem:  an initialization object can't really stand in for
the real object.  It won't respond to the appropriate messages.

This is doable if you stick in a channel to the object instead.  So,
you can't expect to do a synchronous call on an element of your
initialization object.  It will work if there are no circular
references, but may succeed or fail if you are part of a loop
depending on where the loop is entered during serialization.  Not a
happy scene.  Is there a way to automatically catch this error?

The deserialization then becomes:

createFromInitializationObject(Object, &result)

Scenerio:  asdf wraps a ferd, but caches the results of some method
calls on the ferd.  On serialization, the asdf just needs to write out
the ferd, but on deserialization it may want to make those calls to
refresh the caches.  There's no way the asdf can provide synchronous
access to the cached values without actually serializing the caches.

But, this doesn't really have to be dealt with just yet.  A basic
serialization system can support parse tree encoding and be enhanced
to do this sort of thing later.