runtime: Reimplement (call/cc) using setjmp

This is a reimpementation of (call/cc) using stack copying and
setjmp/jongjmp. This saves a "continuation base" which is the stack
pointer of the launchWorld() function. Then, when (call/cc) is invoked
the stack from the continuation base is copied on to the heap and it's
GC-related data structures are relocated to point to the new addresses.

When the garbage collector encounters an escape procedure it will
extract its continuation and then visit its relocated shadow stack,
strong refs and weak refs. This code is shared with the normal GC path.

Upon invoking an escape procedure the stack is copied back in to place
and the GC data structures are "delocated" back to their original
address.

(call/cc) works in the cases it did previously in addition to now
supporting multiple invokations and calling "down" the callstack.
However, the interaction with dynamic states is completely broken and
needs to be fixed in the following commits.
stdlib: Fix possible missing return value

If setjmp() returns something unexpected we assert() to stop execution.
However, on release builds assert() is compiled out meaning execution
will simply fall off the end of the function. Use abort() to ensure
release builds exit in that case.
runtime: Don't validate cell types in release

The (call/cc) rewrite reduced the speed of the garbage collector by
refactoring some functions out-of-line and adding additional checks for
escape procedures. Mitigate this somewhat by only exhaustively
validating the cell types for debug builds - release builds will only
check for cell types that have known references to other cells.
runtime: Cleanups

- Remove unused EscapeProcedureClosure

- Remove unused includes from EscapeProcedureCell.h

- Don't refer to reference counting in the State.h header
runtime: Dynamic state support for (call/cc)

- Add DynamicStateCell that is simply a wrapper around a State* object
  for garbage collection purposes. This allows our normal copying GC to
  be used to visit and track dynamic states

- Make codegen place a GC barrier when pushing a dynamic state to take
  in to account the possible GC when allocating a DynamicStateCell

- When switching states check if the destination state is a descendant
  of the current state before popping the state. If it is then keep
  entering states until we reach the desintation.
runtime: Include cell ref ranges directly in World

A CellRefRangeList consists of a single pointer to the list head.
There's no point allocating that pointer on the heap and double
indirecting through it. Instead, we can just include the head pointer
itself in World. This matches what dynamic::Continuation does.
typegen: Add "runtime-only" cell classes

Runtime only cell classes are hidden even from the compiler. This means
its type system doesn't know about the cell type and it won't generate
range metadata including the type ID. This is only used for dynamic
state cells at the moment.
runtime: Add additional comments re: (call/cc)

This fills out some comments in Continuation.h and
EscapeProcedureCell.h now that the implementation is settling down
runtime: Fix continuations on x86

Continuation::capture() compiled at -O0 was choking when attempting to
return a structure to the caller. It appears that it was creating a
temporary structure on the stack before returning it in EAX/EDX. At
higher level optimisation levels this would have been optimised to
direct stores to EAX/EDX. I'm not sure why the allocation failed but
it's being performed on an essentially undefined stack so this isn't
surprising.

Instead have Continuation::capture() always return itself and have the
caller check ->passedValue() itself to determine if its in a capture or
resume return. This avoids the problematic stack allocation and is
actually cleaner.
runtime: More efficient stack pointer calc

We don't need a separate canary value to determine the stack pointer -
we can use the stack pointer variable itself. This saves 4 bytes on the
stack of the capture and resume paths
runtime: DOn't root the passed value in (call/cc)

Instead of explicitly rooting the passed value in the (call/cc) resume
path teach the garbage collector how to visit the passed value for a
given Contiunation object. Also ensure the passed value is nulled out
after it's used by changing the accessor method to "takePassedValue" and
having it null out the value internally.

This is done entirely to reduce the amount of code and in particular
stack manipulation that occurs in the contination resume path after
longjmp().
runtime: Add leak checking for record-like data

This ensures that record data (including continuations) aren't leaked.
It increments a counter for every call to allocateRecordData() and
decrements it again whenever the finalizer frees a non-inline record
like.
runtime: Force collect when switching dynstates

If _LLIBY_ALWAYS_GC is enabled then force a collection whenever
switching between dynamic states.

Switching states can always potentially collect as the states have can
have before/after procedures that execute arbitrary Scheme code.
However, this doesn't happen frequently. Force a collection to ensure
that callers are rooting their values correctly.
runtime: Root continuation in the resume path

We were using the Continuation object to pass values back to the caller.
However, if it wasn't rooted in the resuming continuation it could be
cleaned up by GC when we switch dynamic states. With our new GC-happy
debug switchStates() this showed up as crashes and valgrind reports.
Implement (raise-continuable)

This adds a SchemeException::resumeProc() that stores the escape
procedure pointing to the (raise-continuable)'s continuation. When an
exception handler returns from an continuable exception that
continuation is resumed instead of rethrowing the original exception.
stdlib: Implement (reverse)

This is used by one of the (dynamic-wind) examples in R7RS
compiler: Treat PushDynamicState as allocating

Pushing dynamic states now allocate an internal DynamicStateCell to
allow the GC to track the state. While codegen correctly inserted a GC
barrier the planner didn't consider PushDynamicState to be an allocating
step. It some cases it could hold a cell allocation across the barrier
which would invalidate the allocation.

This also adds an explicit check in codegen.GenGcBarrier to ensure no
live cell allocations are held across GC barriers
compiler: Add *dynamic-wind) test from R7RS

This is similar to the existing test we had for (dynamic-wind) except
this tests switching between a (dynamic-wind) and a parent state instead
of two sibling states.