Enable exception support in the runtime

This involved removing -fno-exceptions and making the DatumCell
destructor public
Remove "nounwind" from most function defines

Now that exceptions may actually be thrown we need to generate unwind
information. A few exceptions are made for trivial or performance
critical functions (lliby_init, _lliby_alloc_cells, etc)
Add _lliby_launch_world

Instead of having the compiler directly invoke __llambda_exec have it
pass a pointer to __llambda_exec to a new _lliby_launch_world function
that will then call _exec.

This has a number of advantages:

- We have a place to inject a top-level exception handler for Scheme
  exceptions. At first this will just print the exception information
  but in the future it can do an orderly cleanup of the world without
  affecting other worlds

- Once multiple worlds are supported this will be the API the launch
  them. Each world will get its own GC allocator, dynamic environment,
  etc. The world pointer can be passed to the world entry point which
  gets around the terrible TLS support on Darwin.

- We can grab the base stack pointer for stack-copying continuations.
  Continuations will never be able to escape _lliby_launch_world so this
  is the natural place to do it
Initial exception support

This builds on top of C++ exceptions with a special SchemeException
class. This makes it safe for exceptions to be thrown in normal runtime
code and expect destructors etc. to be called. This is in contrast with
Scheme continuations which will require great care on the C++ side to
handle arbitrary number of returns through the same code path.

A small change was required to allow copying of AbstractRefs so that
exceptions can cleanly GC root their raised object while the exception
is being handled.

This is nearly useless as it's not possible to catch an exception
without immiediately rethrowing until continuations are supported.
SImplify the datum_cast<> infrastructure

Remove the otherwise unused ::fromDatum() members for each cell type and
instead have datum_cast<> use ::isInstance() directly. This has a few
advantages:

- The special case for DatumCell itself is removed. The compiler should
  generate identical code

- The two useless ::fromDatum() functions are removed from each
  generated cell file. This reduces code and should help compile times

- This makes it easier for pseudo-cell classes like
  ParameterProcedureCell to use the datum_cast<> infrastructure by
  overriding ::isInstance to do the right thing.
Properly dynamic unwind on error
Add support for expecting certain output in tests

This is going to be required to test exception related things as
currently there are no way to prevent exceptions from being rethrown to
the top level. What we can do instead is exit cleanly at the last
exception handler and then examine the output produced. This is the
first step in that direction

- Add (expect-output) test type that assumes 0 or more datums will be
  printed to stdout

- Add (newline) to print a literal newline and prevent (write) from
  always emitting a newline. This is consistent with what both Racket
  and MIT Scheme do

- Add a trivial unit test for (write) and (newline) that's mostly just
  testing the (expect-output) functionality
Implement (exit), (emergency-exit)

This is intended mainly to support exception handling unit tests.
without (exit) or (call/cc) it's impossible to recover from an exception
cleanly. (call/cc) is a much more complex feature so use (exit) for now.
Implement (error) and add exception unit tests

This adds a new error object cell clasS and implements (error) using it.
This also adds unit tests for our current exception support.
Signal errors as exceptions in the runtime

Introduce a new signalError() utility function that raises a new error
object with the passed message and irritants vector. Anywhere the stdlib
was using _lliby_fatal to signal a recoverable error switch to
signalError().
Significant rework of cell allocation planning

- Remove liveAllocations from GenerationState. Only one allocation can
  logically be active at once. Replace with currentAllocation instead
  which is initialized to an empty allocation

- Don't add ps.AllocateCell steps explicitly. Instead rename the
  MergeCellAllocations conniver pass to PlanCellAllocations and make it
  mandatory

- Make CellAllocation track the number of cells left and return a new
  CellAllocation object whenever cells are consumed. That will allow us
  to properly unwind an allocation before signalling an error.
Switch compiler to _lliby_signal_error

This makes runtime casts to subtypes and record classes throw an
exception instead of triggering a fatal error. The most delicate part of
this is unwinding any partially consumed allocations. At the same time
actually pass through an irritant in GenCastCellToSubtype to ease
debugging.
Print exception strings unquoted

Just print the string's raw UTF-8 data instead of printing the message
cell as a datum. This prevents it from being quoted and escaped which is
a bit easier to read.