Abstract MemoryBlock interface

Abstract out MemoryBlock as an abstract base class and add
DynamicMemoryBlock as its only implementation. This will come in useful
later when the world has static memory blocks embedded inside
Add a test for huge (25MiB) GC allocations

This currently fails due to our small fixed heap size. This should work
with a segmented heap, however
Add CellTypeId::Invalid

This will be used by the new heap allocator for its special segment/heap
terminators
Implement a segmented heap allocator

This grows the heap in increasingly large segments instead of using a
fixed semi-space size. At the moment there is no mechanism to
automatically trigger GC
Make sure lots of allocations don't crash
Re-enable forced garbage collection

After 24MiB of allocations we'll enter the garbage collector on the next
allocation. If LLIBY_ALWAYS_GC is enabled then the GC is entered after
every allocation as before.
Don't explicitly initialize gcState

Make the AllocatedCell GC state have a value of zero and depend on the
fact that mmap() will give us zeroed memory. This speeds up large
allocations as the allocator doesn't need to pass through the memory
once just to have the same memory touched later when the type ID etc.
are set by the cell consumer.
Simpify AbstractRefRange

Remove support for the move constructor now that it's unused. This
allows us to skip a null pointer check in the destructor
Lazily allocate the cell ref range lists

Using the branch instruction we recovered from the last commit start
lazily allocating the cell ref range list. This is important as the weak
ref list is never used outside of unit tests so we can save a 4KiB
allocation for each world.
Convert trivial uses of (call/cc) to returns

- Add et.Return to express early returns in lambdas

- Change codegen to have "BlockTerminated" as a possible result from
  step generation. This is used to stop code generation and fix up phis
  if an early return is encountered

- Look for (call/cc (lambda (return) ...)) and convert all uses of
  (return) to early returns and remove the (call/cc) if possible.
Fix for segfault when applying non-list

- Make the functional test runner fail tests that exit with SIGILL,
  SIGABRT, SIBGUS, and SIGSEGV even if failure was expected. It should
  not be possible to segfault a llambda application under normal use

- Pass the right value for the irritants list when complaining about a
  terminal non-list in (apply)
Add stub call/cc implementation

This doesn't hugely improve our R7RS compliance but will allow a few
more trivial cases to work and can serve as a basis for future work.

- Change TrivialCallCcToReturn to not abort completely if a
  non-replaceable use of the exit procedure is found. Instead, make the
  replacements but keep the original (call/cc) wrapper. This means that
  trivial uses of (call/cc) will be optimized to returns even if the
  procedure has non-trivial (e.g. capturing) uses.

- Add a stub (call/cc) implementation in lliby that passes a procedure
  that will signal an error if invoked
Merge branch 'segmentedheap'
Garbage collector fixes

- Have codegen create constants with the correct GC state

- Make _LLIBY_ALWAYS_GC actually always GC instead of every 3rd call

- Make ForwardingCell using CellType::Invalid. This doesn't change
  behaviour but is a bit more clear when inspecting memory or debugging