Accept Encoding object for Encoding.compatible?

With this change, the following calls are supported:

    Encoding.compatible?(Encoding.find("UTF-8"),
                         "String".force_encoding("UTF-8"))
    # => #<Encoding:UTF-8>

    Encoding.compatible?("String".force_encoding("UTF-8"),
                         Encoding.find("US-ASCII"))
    # => #<Encoding:UTF-8>

    Encoding.compatible?(Encoding.find("UTF-8"),
                         Encoding.find("US-ASCII"))
    # => #<Encoding:UTF-8>
[IR] Properly handle breaks in evals in 1.8 and 1.9 mode.

* lambda { eval('break') }.call completes in 1.8 mode but in
  1.9 mode throws an exception.
* No change in mspec runs (is rubyspec missing a spec for this?)
[IR] Tweaked interp. break handling to test JIT use-case.

* There is no need to check for break-jumps for all instructions.
  It is sufficient to wrap only those calls that pass closures
  as follows:

      try {
          call(... &blk)
      } catch (IRBreakJump e) {
          handle-break
      }

  There is an added advantage to this pattern in that this lets
  interp detect local-jump-errors more accurately without needing
  access to the block itself.  This pattern has been tested and
  verified that it passes additional break specs without hurting
  interp performance but has been commented out in this patch.

  However, this pattern requires that lambdas be treated specially
  since this is a valid use case:

      l = lambda { break; }
      l.call

  This is fixed by detecting break invocations in lambdas and
  handling them like regular returns.  This tweak is now present
  in the IRRuntimeHelper break handling.

* More fixes to come in this vein in the following patches.
[IR] Inline break handling into IR instruction stream.

Commit f9d0e85 introduced an inline break-handling pattern and
verified its feasibility.  This commit now transforms all calls
that might receive breaks into the following pattern in the
IR instruction stream

   try {
       call(... &blk)
   } catch (IRBreakJump e) {
       IRRuntimeHelper.handleBreak(e)
   }

Introduced a RuntimeHelperCall instruction for invoking a runtime
helper to handle the break in the rescue block.  In the future,
this instruction might expand to handle other runtime helpers in
the JIT.

The interpreter in turn no longers protects calls with a try-catch
but instead introduces an additional catch clause into the existing
RaiseException try-catch statement to handle IRBreakJumps.  In the
JVM bytecode (when JITted),  this effectively transforms into
additional exception table entries and is handled by the JVM
without any additional work to be do by the JIT.

This patch now eliminates all break-jump spec failures (previously
we had 4) since breaks from escaped blocks no longer receive
blanket-protection. They just bubble up to be trapped by a lambda
or get to the toplevel and halt execution.

TODO: Verify that if some piece of code has a LocalJumpError
rescue, that code runs properly (check if RubySpec has specs for
this already).

There is no performance penalty from this patch.
[IR] Interpreter loop simplification and cleanup.

* Added interpretAndGetNewIPC method to control-flow instructions
  and moved inlined code out of interpreter loop into respective
  control-flow instructions.
* Minor reorg of case stmts into logical groups.
* Minor performance improvements across the board.
* Overall 3% - 20% performance improvements across different
  benchmarks since commit 99f51d5.
* Yet to be done: inlining of non-local-return handling into
  instruction stream.
[IR] Addl. streamlining of exc. handling in interpreter loop.

* Make the three catch clauses (RaiseException, BreakJump, Throwable)
  in the interpreter loop similar in pattern making it possible to
  unify them further by moving dissimilar code into the instruction
  stream.  This will bring the interpreter and JIT code much more
  in line with each other by eliminating all special handling from
  the interpreter loop.
* No change in mspec runs.
* Additional minor performance improvement across all benchmarks.
[IR] Consolidated all interp. exc. handling into one catch block.

* Last bit of cleanup for now.
* Next step would be remove the last of the special case from the
  interpreter and moving it to the instruction stream.
* Keep instance as long as the MetaClass is referenced.
* Better failure message
Fix JRUBY-7046 - always copy files in 128M chunks.  Might be slightly slower than the optimized version that tried to transfer the entire file with the fallback, but that one relied on parsing exception messages, and I think the fallback was broken anyway (always copied from the same file position).
Discard $JRUBY_OPTS if we are starting the nailgun server.

This addresses JRUBY-6953.
Add const_get to java package Fixes #435
Call to_path on objects passed to IO.copy_stream
Do not close the io's given to copy_stream
Raise IOError if file not readable or writable
Increment from io position by transfer size
Add length and offset args to IO.copy_stream
[IR] Breaks and non-local returns handled entirely via IR instrs.

* Removed last bits of special case handling of breaks and
  non-local returns from the interpreter by adding global exception
  handling in methods (those that receive nonlocal returns) and
  all closures (for stopping uncaught breaks in lambdas).  Since
  there is no syntactic/lexical way of distinguishing lambda closures
  from proc and other closures, we need this check in all closures.
* This patch does affect performance of intepreted code in some
  cases.  For example, most of the perf. benefits gained from
  recent patches are lost with this change.
* Worth investigating more closely and maybe selectively enabling
  this only for JIT-ted code, if necessary, for example.
We survived the Mayan Apocalypse!
Eclipse: filter out gems from scanned resources

lib/ruby/gems/* gets bigger and bigger and make Eclipse file scanning
slower.