That is brilliant. I think we should prototype and experiment wirh various
synthesis/parallelizing solutions.

If we do our work well on the LPC GD engine side, we could first design the
basic concept:

1. Either the LPC code, or the engine, initiates the "offloading" of a certain
desired highly computationally heavy function, and/or its scheduling a highly
demanding amount per second

2. The object is marked as being in transit for offloading / parallelization.
All incoming calls to it are put on hold / in wait queue.

3. Probably the whole VM needs to be paused.

4. The object and its source code are sent, let's keep it simple and
debuggable, by writing the metadata and source, into a "resynthesis" queue dir
on the VM host.

5. The VM creates a dedicated high speed comm channel for receiving and
sending updates from/to the parallelized resynthesized version of the object.

6. The VM waits for the offload/resynth job to be marked done, with a timeout.

7. Upon timeout, the attempt is reverted with error printed.

8. Upon success, the VM routes all calls to the object to the parallelized
version comm channel.

9. The VM gets updates and the object-initiated calls to other objects from
the comm channel.

10. If the parallelization process dies or signals yielding of mission, VM
resumes normal operations and marks the object as normal