Simple first pass of garbage collection

This provides three classes to allow the runtime to cooperate with the
GC:

- alloc::StrongRef is a strong reference to a GC managed object. These
  act as GC roots and the pointer values are automatically updated to
  their new location
- alloc::WeakRef is a weak reference to a GC managed object. These are
  not GC roots but do have their pointer values updated if the value is
  otherwise reference
- alloc::StrongRefRange will GC root a range of externally allocated
  root pointers. This has a few minor use cases related to constructing
  lists and vectors

When the current semi-space is exhausted a new semi-space is allocated
and alloc::visitCell() is used to visit each reachable cell and move it
to the new semi-space. Any weak references to live cells are then
updated to point to the value.

The runtime remains completely GC unsafe. The next commits should
resolve the most obvious issues.
Rename _lliby_alloc_start to _lliby_alloc_next

_lliby_alloc_next moves forward with every allocation, similar to a
stack pointer. _lliby_alloc_start seems to be more indicative of a
static value and could be confused with the semi-space start.
Make the bindings and their unit tests GC safe

This ensures that all datum pointers are properly referenced before
allocating any values. All unit tests now pass with GC and
_LLIBY_ALWAYS_GC enabled.
Explicitly give a body for _lliby_alloc_cells

The previous method of aliasing the name didn't work (on Mac OS X 10.9
at least). There was also a potential issue on 32bit systems where the
compiler was expecting it to take std::uint64_t while the function was
actually taking a size_t

Fix by giving _lliby_alloc_cells a function body that just directly
calls allocateCells. This is a slow path so it shouldn't make any
measurable difference.
Crawl the GC roots provided by the compiler

This will respect and update any GC roots provided by codegen. With this
commit trivial cases of GC actually work correctly: over 95% of the
functional tests pass with _LLIBY_ALWAYS_GC enabled.

The major holes now are GC unsafety in the stdlib and support for
record/procedure types.
Initial GC safety fixes for stdlib

- Make (list-copy), (cons), (vector) and (apply) properly root live
  values across allocations

- Remove InexactRationalCell and ExactIntegerCell's constructors and use
  a static ::fromValue() instead. This fixes places where the allocation
  was happening first then the constructor arguments were computed using
  an invalidated pointer to another cell.
Improve external form for procedures

- Include the entry point for the procedure in the external form

- Distinguish procedures capturing variables (#!closure) from those not
  capturing ($!procedure)

This is primarily intended to help debug garbage collector issues but
should be generally useful
Add _LLIBY_NO_ADDR_REUSE

This is an additional GC debugging flag that causes the allocator never
reuse semi-space address space and instead discard its pages and mark it
as unreadable. Otherwise the same address space will likely be reused
for a later allocation and stale pointers might silently keep working or
cause delayed misbehaviour.
dumpReachableFrom enhancements

- Prefix dumped data with their memory address. This is useful for
  correlating with GC backtraces etc.

- Add a flag to disable the dumping of global constants. These are
  generally uninteresting when debugging garbage collection

- Track which cells we've dumped and don't dump them again if they're
  reachable from multiple cells.
Support garbage collection for record-like types

- Fix codegen to set the proper bit for inline cells. It seems dodgy
  online hex converters shouldn't be used for important constants

- Include a fake _llambda_class_map for the runtime unit tests. Weak
  symbols were attempted but require a lot of compiler/linker specific
  magic. Simply including a null one is easier

- Use the class map to iterate over all datum pointer in record-likes
  inside alloc::visitCell
Support for finalizing cells after GC

This finalizes vectors, bytevector, strings, symbols and record-likes by
deleting their heap data after they're garbaged collected. A small
change had to be made to mode the inline data flag in to the record
cell. This exisiting class map didn't contain entries for types without
embedded datums so it was impossible to tell if record-likes with only
native values were inlined.
Introduce MemoryBlock

MemoryBlock is an abstraction on top of directly mmap()'ed memory. It
tracks the start pointer and size of every block and will munmap the
region in its destructor. This is intended to assist the concurrent
finalizer changes but should also be useful when multiple active blocks
are supported
Move finalizing to a separate thread

It's completely safe to finalize the old memory block asynchronously as
there should be no remaining references to the old block. In a test that
repeatedly creates garbage (half with heap data, half without) this
reduces the total runtime by 10% on a 4 core system.
Fix GC when allocating a multi-cell range

The GC assumed every cell in the memory block was valid at GC time. This
is true when allocating a single block but will not be true when a range
allocation fails. Make sure we only update _lliby_alloc_next on success
(like the compiler does) and then use that as the real end value during
GC
Small optimization to AbstractRefRange

Instead of creating a value on the stack and copying it in to the list
use the move constructor. This might compile to the same code but it's
nicer to read anyway