Thread-local and concurrent contexts can nearly reclaim thread locals.

Java unfortunately offers no official way to clean up thread locals
without having each thread that owns a copy execute `remove()`.  When
JRuby is embedded in an application as a plugin in a larger system,
this can be hard or impossible to arrange.  In this scenario
`ConcurrentLocalContextProvider` and `ThreadSafeLocalContextProvider`
are basically forced to leak their thread locals.

However, this does not mean they must leak the referenced
`LocalContext` objects.  If those could be reclaimed, then the lion's
share of resources would be garbage-collectable, even if the thread
locals themselves leak.  Importantly, this would also allow the
relevant jruby classloader to be collected to enable hot-unloading in
embedding/plugin scenarios.

By wrapping each `LocalContext` in an explicit, mutable reference and
tracking those references, the providers can still make the contexts
unreachable without the help of other threads.  This is what we do
here.

In each provider:
* `ThreadLocal<LocalContext>` becomes
  `ThreadLocal<AtomicReference<LocalContext>>`
* A `volatile ConcurrentLinkedQueue<AtomicReference<LocalContext>>` is
  added to accumulate new `AtomicReference<LocalContext>` instances as
  they are created
* `terminate()` walks this collection, cleaning up each context and
  setting its owning `AtomicReference` value to `null`.

The `volatile`, combined with setting the container to null, takes
care of a race condition between `initialValue()` and `terminate()`.
[Truffle] - Cleaning up list of failed rubyspecs. Keeping only the ones that are failing.
[IR] Fix ReceiveExceptionInstr.cloneForInlining
[IR] Minor code cleanup.

* toStringVariables is not really useful since all scopes
  have their CFG built always.
[IR] Bug fixes handling returns in the presence of ensure blocks

* In IR mode, the following code would print '2' instead of '1'
  which is the expectation.

def foo
  v = 1
  begin
    return v
  ensure
    v = 2
  end
end

p foo

* Fixed IR building (and OptimizeTempVarsPass) to implement this
  behavior.

* Overhaul of ensure block IR is coming up in coming days that will
  eliminate some of this complexity.

* No change in rubyspec run (we are missing a rubyspec for this)

* TODO: Add new rubyspec test
[Truffle] use JRuby’s Posix object.
[Truffle] Use JRuby’s current directory.
[Truffle] Use JRuby’s warning mechanism.
[Truffle] Use Joni for regexps.
Merge pull request #1418 from lucasallan/rubyspecs-truffle

[Truffle] - Cleaning up list of failed rubyspecs. Keeping only the ones that are failing.
[Truffle] More regexp specs pass.
[Truffle] Lots of send specs now pass.
[IR] Split ReceiveExceptionInstr into Ruby and JRuby-impl exceptions

* ReceiveRubyException is used in native Ruby rescue handlers.
  It rethrows unrescuable exceptions. As for other exceptions,
  it unwraps the exception object to reveal the native Ruby
  exception object and passes it through to the rescue handler.

* ReceiveJRubyException is used in JRuby-implementation-inserted
  rescue handlers. These are break handlers, non-local-return
  handlers, ensure handlers, scope-global ensure handlers inserted
  during optimizations. These handlers do not unwrap the exception
  object and only examine them for JRuby-implementation exception
  types where necessary (breaks, non-local returns).

* While this could still have been handled with a single exception
  instruction, the split in semantics makes this cleaner/clearer and
  could possibly enable other specialized handling in the future.
Make all closure automatically register with lexicalParent (note: this will also make post/pre exe blocks do this)
Change how labels are stored to be {prefix, id}.  A few minor encode/decode fixes
Sort more debug output to reduce diff size when comparing encode/decode
Remove LocalVariableAllocator
Rudimentary writing of lvars so when read back in all offsets are the same
remove catch-all exception to fail faster in decode. Fix non-local return not encoding its return result
[Truffle] Implementing method #=== for Ranges.