Generate "Fields" traits for cell types

This is a parallel hierarchy to the CellType/ConcreteCellType classes
that reflects the inheritance tree of the cell types themselves. Right
now it just contains information about the fields the cell types
contain.
Unify procedures/closures and records

User-defined records are represented by vt.RecordType while the closure
types we internally create are represented by vt.ClosureType. Both types
are instances of vt.RecordLikeType and most of the code only deals with
them at that level of abstraction.

Currently the only closure type is vt.EmptyClosureType which contains no
fields
Support for closing vars by non-captures

In this context "non-capture" means a variable that does not need to be
represented in the closure. Examples of non-captured variables are other
procedures without closures or constants.

The practical application of this is that (scheme base) procedures can
be called from lambdas. This is the beginning of lambdas being useful.
Add support for mutable args to procedures

After we start the plan for the procedure but before we plan the body
initialize all the mutable vars as fresh records. This confines any
mutation to the scope of the lambda body which appears to be the desired
behavior.
Support for capturing variables

This changes the generated function's closure arg back to a "self" arg.
The caller can't easily discover if the procedure has packed its record
fields inline. It has to pass a pointer to the procedure cell and have
the function itself unpack it.

This also implements half-built procedure cells that only contain a
closure but no entry point. These are represented by iv.KnownProcedure.
This can be used when we want to create a lambda capturing a variable
but don't want to build a trampoline because we still know its direct
signature and entry point. The trampoline will be built on demand when
the KnownProcedure is explicitly converted to a procedure cell.