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>
Add const_get to java package Fixes #435
Fix jruby-complete not working with new jossl packaging changes
GH #360: Non-ASCII character escape sequence in string_content results in SyntaxError
Remove libjffi-1.0.jnilib that was checked into git sometime in the past.
Bump version for 1.7.2
update for next dev release
Merge pull request #465 from atambo/const_get

Add const_get to java package Fixes #435
Merge pull request #457 from kou/support-encoding-object-for-encoding-compatible-p

Accept Encoding object for Encoding.compatible?
Reduce cost of repeatedly invalidating global variables.

* Mark all variables as GLOBAL, THREAD, or FRAME scoped
* Only perform indy caching for GLOBAL
* Failover to direct access every time after 100 failures
* Add a failover invalidator that eventually stays invalid

In order to avoid the impact of invalidating global variables that
are modified continually during the run of an application, I've
added a config parameter (invokedynamic.global.maxfail) to fail
those variables and not continue caching them using invokedynamic
and a SwitchPoint. On the update side, I added a new Invalidator
called FailoverSwitchPointInvalidator that eventually gives up and
stays invalid, since even invalidating an unused SwitchPoint is
rather expensive.

With these changes, highly-volatile global variables perform as
well as without invokedynamic, rather than much slower.
Use single-arg version of RubyClass#newInstance(), instead of the IRubyObject[] variant
Use a CallSite per callback parameter - a particular callback param almost always receives an instance of the same class.
Change MemoryIO from an interface to an abstract class, and hoist isDirect and address into the base class, so isDirect() and address() are monomorphic calls.
Check that the RubyString stored MemoryIO is of the same type (direct/heap) as the requested type before using it.
Speedup to_ptr coercions by using a callsite per parameter
Lookup the MemoryIO directly when convering parameters to pointers, and delay the strategy lookup until the non-direct path is taken.
Limit the amount of recursion for :pointer parameters when passed an object that responds to :to_ptr
Coerce objects using #to_str for :string parameters (for ffi/ffi#242)
Coerce to String instead of raising an error when handed a non-String param (related to ffi/ffi#242)
Instead of calling respondsTo() and then callMethod(), just lookup the method and call via the DynamicMethod instance.