Add function blocks to asm2bc.

Broke up the code a bit --
- Added a generator function which just executes a block and returns
  the last item added to the data array.
- with_named_variables, which is essentially let without a keyword to
  kick it off, so it initiates a scope for a block and undefines the
  variables for that block when done.
- On encountering a return instruction inside a let block, the variable
  preservation code will run, restoring registers. This doesn't occur
  for trap instructions yet, though it probably should.

  It's possible to corrupt registers by jumping outside of a let block
  with preservation since this isn't validated by asm2bc.
- generate_unwind! will generate all pop instructions necessary to
  restore preserved registers on the stack. As usual, this assumes that
  esp is where it needs to be.
- function definition syntax added:

    function name([arg_name_list][; local_name_list]) {
      /* body */
    }

  generates bytecode for exported functions. The arg_name_list is just
  special syntax for a let block that pops its arguments off the stack
  and into the registers given. Volatiles are not preserved for either
  argument or local registers because doing so would mess up the stack.
  As such, the unofficial calling convention is for callers to preserve
  any volatiles they need to before calling a function.

  I may add implicit named-register preservation to asm2bc upon
  encountering a call instruction.
Add implicit let-block unwinding for calls.

This preserves named volatiles regardless of whether they're marked as
preserved, since it's implicitly the caller's responsibility to handle
volatile register preservation.
Rename validate block to process.

I'd like to now use this for something.
Add explicit register aliasing.

Any let block or a function's arguments may use the syntax varname(reg)
to alias a specific register. Automatic Register allocation will skip
already-aliased registers, as usual.

E.g.,

  function name(name_1(%24), name_2) { ... }
  let name_1(%24), name_2 { ... }

Where name_1 is aliased to register %24 and name_2 is aliased to
register %4. Reserved registers may not be aliased and named registers
may not be used as register targets. As such, you cannot do a(b) where
b is any named register, nor can you do a(%3) because %3 is rp and a
reserved register.