Death to rubyclass stack: Part 1 of 2

* When methods are defined, aliased, undefined, the runtime has to
  determine the method container that is affected by the changes.

  Thus far, this was done by manipulating a rubyclass stack that
  is updated at several places in the runtime and weaves its way
  through frame, binding, yield, instance/module/binding evals,
  and is updated on every call.

* This patch implements a fairly straightforward algorithm for
  determining the method container at the time it is needed by
  examining the contents of the lexical scoping tree starting at
  the scope where the method is manipulated. This examination is
  affected by runtime flags set on lexical scopes (always blocks)
  based on whether any of them are being executed in the context of
  instance/module/binding evals. There are couple special cases to
  this algorithm. Nevertheless, it is far more straightforward and
  easy to grok than the existing runtime implementation.

  In this patch, the rubyclass stack manipulation code is turned off
  in ThreadContext.java but the rubyclass stack and its traces in
  the various parts of the runtime are left behind.

  The algorithm relies on annotation of block scopes when they are
  being executed in the context of evals. The bulk of this patch
  involves setting up these annotations in RubyModule, RubyObject,
  RubyBasicObject and passing them to DynamicScope via Block, BlockBody,
  IRBlockBody, and InterpretedIRBlockBody.

  The algorithm also relies on annotation of static scopes with the
  IR scope type. The other bulk of this patch is in setting up those
  annotations on IR static scopes.

* The algorithm itself is in ir/runtime/IRRuntimeHelpers.java
  - findInstanceMethodContainer(..)

  It is easy to split this up into static/dynamic since there are
  scenarios where the container is statically determined. But, there
  is no real benefit that we foresee from the static resolution
  scenarios, and the algorithm is simpler the way it is currently
  coded up.

* This passes all MRI tests and Rubyspecs plus other contrived
  tests (they need cleaning up -- will probably add them in a later
  patch).
Death to rubyclass stack: Part 2 of 2

* This patch builds on the previous commit and eliminates all
  traces of rubyclass stack from the codebase.

  - Remove the push/pop/get from thread-context and use sites.
  - Removed klass arg from method calls.

* TODO: embed used to inject values into the current-module obtained
  from the rubyclass stack. That code needs investigation.

* Replaced the hacky if (klass==null) prepareSelf(binding) calls
  with information about actual execution context. The primary reason
  to use binding.self instead of self argument in blocks is when
  the block is being used in a binding-eval context. The same soln.
  is applicable in other contexts where this pattern was used (and
  currently marked with SSS FIXME annotations in code comments).

* All tests continue to pass.