Re-implement mutable vars as records

Replace an explicit mutable type with an internal one-field record.
Everything pass the planner does not distinguish between mutables and
records. This simplifies the code and hopefully will combine the
optimization effort applied to mutables and records.

This has two efficiency downsides:

- We now have to store the recordClassId when constructing mutables.
  This is a constant so it shouldn't be too arduous

- The garbage collector will have to dereference the record type
  information when encountering mutables. This should be cached past the
  first access but is still instruction-heavy
Implement SRFI 111

SRFI 111 defihes a "box" type that's trivially implemented as a
single-field record
Make constants private instead of hidden

Private variables are scoped to the LLVM module while hidden is scoped
to the shared object. We build one module per program so we can help
LLVM's optimizer out by using the stricter linkage.
Rename RecordTypeGenerator to TypeGenerator

The current name is very verbose and awkward. Also, the same
infrastructure would theoretically be used for user-defined vector
types. Rename to something a bit easier to type.
Emit type maps for record types

Type maps will allow the GC to determine which cell pointers exist for a
given record type. This is required for a GC which is both precise and
compacting.
Add arch.TargetArchitecture abstraction

This trait defines properties specific to the target platform. At the
moment this consists of definitions of various types.  Right now the
only implementation is arch.Unix64 but this provides an abstraction to
support other architectures in the future.

Currently it's only used by the library loader to inject the correct
types when (llambda nfi) is imported. In addition to the hardcoded types
it defined before it now also includes definitions for size_t and
wchar_t.