Dynamic state runtime support

This adds a ParameterProcedureCell class to the runtime which is a
normal ProcedureCell with accessors for the contents of its closure.

There is a list of State objects which link to their parents.  Whenever
a parameter procedure is invoked it will walk up the active state's
ancestors. If no value is found it will return its initial value.

Dynamic states can optionally have before/after procedures associated
with them. This is used to implement (dynamic-wind). (dynamic-wind) is
currently equivalent to calling before->thunk->after but attaching it to
the state infrastructure will make it easier to implement continuations
and exceptions

The garbage collector will also crawl the state list and root all
values referenced by the state as well as update their pointers.

The new compiler-facing functions are:

- _lliby_dynamicenv_push creates a new child environment and makes it
  active

- _lliby_dynamicenv_set_value sets the parameter in the active
  environment to the passed value

- _lliby_dynamicenv_pop restores a previous environment
Compiler support for parameterize

This required some generalization and refactor of the compiler to
support new control structures:

- Factor out most of createLambda to extractBodyDefinition. This can be
  used to process the body of any body-like definition such as (lambda),
  (parameterize), (guard), etc

- Add a ps.NestedStep that generalizes steps containing other steps.
  Most intermediate steps dealing with ps.CondBranch now deal with
  ps.NestedStep

On top of this fairly direct processing of (parameterize) is added. It's
extracted by the frontend to an et.Parameterize which is then planned in
to a ps.Parameterize. The codegen simply directly pushes a new dynamic
environment, sets the values, generates the inner steps, then pops the
state.
Change the external form of procedures

- Change #!closure() to #!parameter(closure:<proc>/<entry>). This makes
  closures with the same entry point distinguishable

- Change #!procedure() to #!procedure(emptylclosure/<entry>) to parallel
  the closure form

- Distinguish parameters as #!parameter(parameter:<proc>)
Set the proper flag for always running the GC

This makes GC_ENABLE_DEBUGGING work correctly