Define a 'management' module for loading.

There are a good number of unresolved matters that might be possible to lump under a 'management' module. This might be responsible for early negotiations on the loading of the code, could implement decompression and macro expansion, and perhaps also load time fixups, before the main code runs. It might also be able to manage stopping and restarting the main code to respond to memory pressure etc, to resize the memory, to move from a wasm32 to wasm64 mode etc.

There is already a wasm polyfill, and the loading of asm.js code can already be managed by JS, and perhaps this module could fill a similar role.

A general solution such as this might avoid a lot of spec work on defining a macro layer etc, and leave these as open matters for the community to explore by writing their own management modules.

This could be responsible for negotiating the initial memory size for #331 after which it could compute constants and rewrite the code during macro expansion.

Most languages with macros have some compile time computation support, and this could fill this role.

It might use a separate memory area, with an interface to the main memory once available.

Perhaps like a service worker it could be transient, and restarted as needed.

To support the use case of caching the downstream compiled module(s) based on known upstream input, this module needs to be deterministic and give the same output for the same input stream. It would have no access to non-deterministic inputs, such as the time. Any inputs (apart from the input stream) would be available at start time and well defined (a spec'ed input format), so that they could also be used to determine provenance and reason about cached products without starting the module.

Regarding the inputs. It also helps to know which inputs are used by the module, so that a provenance key can be as specific as possible. So there is both a use for knowing the provenance of all inputs before running the module, but also a use for not just passing a big dump of all known inputs to the module but rather having specific access functions used when the module runs so that the runtime can record which inputs it likely depends on. An alternative would be for the module to computationally return a key, but this requires a greater degree of care and cooperation than a 'web' system might want.