Make BoxedLiveValue use arbitrary possible types

Previously BoxedLiveValue took a specific boxed type and derived a list
of possible concrete boxed types from that specific type. Instead have
NativeToLiveValue calculate the list of possible types and pass that in
to BoxedLiveValue. In the future this will allow BoxedLiveValue to have
arbitrary sets of boxed types. An example of this is conditionals where
the boxed value can have the union of possible types from the true and
false branches.
Support for boxing and unboxing chars and strings

This required some reworking to always pass the module to
ConstantLiveValue instances. This is needed because strings need to
generate a global variable even for unboxed values. Either the module
needs to be passed in to the genUnboxedConstant partial function which
complicates the signature or the module can be passed in before. The
latter seemed cleaner
Make integer constants 64bit clean

Interally Scheme integers and LLVM integer constants were represented
with scala.Int. This is a signed 32bit integer and cannot represent the
full signed 64bit range of our exact integers. Switch to scala.long and
add unit tests for both parsing and code generation.
Implement (exact) and (inexact)

These convert numeric values to their corresponding exact or inexact
representations. If a conversion can't be losslessly made the procedure
will fail
Boolean fixes and rework

- Instead of only supporting 8bit C-style booleans also add a
  genTruthyPredicate() method which returns an LLVM i1. This can be used
  directly for LLVM conditional branches

- Fix a number of boolean conversion corner cases and add unit tests to
  cover them.
Expose (vector-length)

This was present in the standard library but untested and not exposed in
core.scm
Split {Constant,Unboxed}LiveValue to own files

BoxedLiveValue is already a separate file so the current arrangement is
inconsistent. BoxedLiveValue could be folded in to LiveValue.scala but
that would make the file uncomfortably large
Support extending and truncating unboxed ints

This is required to e.g. pass an unboxed i64 to a function expecting an
i32. The same code is also be reused for the boxing code which needs to
convert to a signed i64 first
(length) improvements

- Move the implementation of (length) from stdlib/list.cpp to
  BoxedListElement.cpp. This allows the implementation to be accessed
  from other callers in the runtime

- Check for improper lists and return InvalidListLength if one is
  encountered

- Change (length) to abort with a fatal error if an improper list is
  passed. This is consistent with R7Rs which defines (length) as taking
  a proper list

- Add C++ unit tests for BoxedListElement::listLength() on proper and
  improper lists

- Add Scheme functional test to ensure (length) on an improper list
  fails
Add simple branching with unit tests

The (or) tests fail because they depend on lambdas. The next commits
should work around that by flattening self-executing lambdas
Improve 'Unexpected type for boxed value' message

Include the expected and passed types in the exception message
Introduce et.Begin

This is analogous to the (begin) syntax in R7RS. It's to allow
optimization passes to replace a single expression with an arbitrary
number of other expressions. Ironically R7RS (begin) is initially
represented as a self-executing lambda in the expression tree instead of
an et.Begin.
Make BoxedType.genTypeCheck cast to a %datum*

genTypeCheck was implicitly assuming that it was being passed a boxed
datum. This is usually true but occasionally a more specific type is
known. Cast to a %datum* first so callers don't need to worry about it.
Implement (list-copy) and (make-list)

These are intended mostly as sanity checks for the upcoming work on the
allocator. This is because they allocate all their memory in a large
chunk instead of pausing GC. They ensure that the allocator can sanely
hand out multiple conses in one allocation.
Add et.Expression.map

This applies a function to each of the subexpressions and then returns
an expression containing those modified subexpressions. Along with
et.Begin this should allow clean and monadic optimizer code.
Add FlattenSelfExecutingLambdas optimizer pass

This turns trivial self-executing lambdas in to et.Begin expressions
that assign the functions parameters to variables and then run the
former lambda's body.

This is required at this early stage because many macros such as (begin)
and (let) are defined in terms of self-executing lambdas. Before this
commit they would cause code generation failures due to unimplemented
lambda support. In the future this optimization pass will still be
beneficial to avoid function generation/call overhead and preserve type
information.