Get binding capture working properly.

There's several not-so-nice hacks in here to avoid trying to store
the %block value to scope. Unsure which direction this should go.
Fix IRStaticScope not getting variables declared.

Variables were being defined in two places: by the parser, as it
encountered them; and in the process of building IR. This included
both the typical Ruby local variables, found by the parser, and
hidden variables added by IR. Unfortunately the hidden variables
added by IR did not go into the static scope, so when the compiler
tried to encode that scope some names were missing. This led to
variable offsets being off and the eventual DynamicScope not being
large enough.

This change adds logic to:

* Register each variable name with the static scope as it is
  handled in IR building.
* Use the StaticScope's index rather than the current variable
  count. This is necessary since the StaticScope will already have
  assigned offsets to normal Ruby locals, so they will not match
  the order they are encountered by IR building.

With this change, the IR JIT now appears to stand up a binding
scope correctly, save true locals correctly, and save the hidden
%block local correctly, as shown by the following snippit (which
works):

def foo; a = 1; eval 'yield a'; end; eval 'foo {|i| p i}'

There's no support in the IR JIT for closures yet, bit this
example shows that variables are now being reified into the
binding correctly.

Note that this commit also adds the explicit load/store
instructions to interpreted mode. Some of the issues I encountered
would have been apparent in interpreted spec runs had we enabled
this pass. I turned it on, and we'll deal with the fallout by
fixing it, since I need this pass to work right.