Reserve 10 TBAA nodes for the world structure

The world pointer will usually be the hottest data structure. Make sure
we TBAA it to prevent unnecessary reloads.
Add ProcedureSignature.hasWorldArg

This indicates if the procedure requires a pointer to the current world.
This is currently false everywhere except for the ProcedureSignatureToIr
unit tests.
Introduce empty World object

- Change _lliby_launch_world to pass a newly allocated World pointer to
  the entry function

- Make __llambda_exec take an (unused) world pointer
Assume lambda take a world ptr

Change PlanLambda to assume lambdas take a world ptr and then change
InferArgumentTypes to remove it if it's unused. This is a no-op if
optimization is enabled as nothing uses the world ptr.
Pass the world ptr to functions that require it

No functions except __llambda_exec require the world ptr so this is a
no-op.
Add world-pointer to (native-function) syntax

If world-pointer is in the initial position of a native function the
signature is indicated to take a world pointer
Get rid of useless dynamic.h

These compiler support functions are unused by the runtime. If they're
needed again later the new style is to expose the implementation as a
namespaced C++-style function or class with the C compiler support
function being a thin wrapper.
Make adapated procedure signature take a worldptr

Adapted procedures need to have the most generic signature possible. To
make it possible to adapated procedures to wrap procedures taking a
worldptr it must take a worldptr itself.

Most of this change is merely fallout from this. (apply),
(with-exception-handler), (dynamic-wind) etc all need to have a worldptr
to properly apply Scheme procedures. This leaks in to a fair number of
other stdlib functions indirectly and serves as a good first test of
passing around worldptr
Move the active dynamic state to World

This is the first value contained inside World. This isn't useful itself
but it's a good test that the pointer is being preserved at least some
of the time. This required a hack to track the current active world to
ensure the allocator doesn't require it (yet)
Change world-pointer to world-function

The world-pointer form didn't work properly with rest args. Give it its
own expression, (world-pointer), which also emphasises the compiler will
treat the function specially.
Add WorldPtrValue

This is just an empty subclass of TempValue to make type safety and
implicit work better
Move the strong and weak ref list to world

This had a large fallout due to the fact signalError() requires GC
rooting. This extends all the way to codegen which now needs the
worldptr for signalling errors and from there the planner which now
needs it for type casting.

At the same time perform some cleanups and refactoring on
CellRefRangeList
Pass a dummy world pointer to _lliby_alloc_cells

This is currently unused but it should represent the final changes to
the compiler required for world pointer support.

The code is a bit messy because the world pointer isn't actually used
until PlanCellAllocations which is the very last step of planning.
InferArgumentTypes and DisposeValues need to special case the world
pointer as to not optimize it out.
Make allocateRange take a dummy world pointer

This has very little fallout - most of the functions allocating ranges
also needed to GC root.
Pass the world pointer to the allocator

This is currently unused but prepares for moving the allocator state in
to the world.
Remove World::activeWorld()

This makes forceCollection() take a world pointer and pass that in to
the collector. The GC root list is then taken from the world but the
allocation area is still a global variable.
Split alloc::init in to initGlobal/initWorld

initGlobal will start the finalizer thread while initWorld/shutdownWorld
will create the allocator state for a specific world
Move the active memory block to World

This doesn't change any functionality yet
Move allocNext/allocEnd to World

This finally makes the runtime state contained to the World and allows
independent GC areas to co-exist
Don't treat non-world functions as GC barriers

It's not possible to allocate memory without access to a world pointer.
This allows us to avoid synchronizing our GC state across read-only
runtime functions.