Use a more esoteric encoding in IO.new tests

This is to fix some specs that were failing on a system where the
default external encoding was already set to ISO-8859-1.

As the :internal_encoding option is ignored when it is the same as the
external encoding, certain tests would fail due to the IO object's
internal encoding being nil.
Restore failing tags for spec that was passing as a false positive

When run on systems where UTF-8 is the default external encoding, a
particular spec was passing when it shouldn't have. Running it on a
system with a different default encoding revealed the issue.
Simplify logic in finalizer for scanning mature objects
Use unsigned int for marks consistently
Remove more unnecessary usage of &block from kernel classes

As per ad47350, creating a Proc for the block that's passed into a
method incurs a performance penalty. This commit removes a few
occurrences of methods defining a &block argument without using it.
Add specs for Unicode character and script properties
Always retry parsing Regexp with original pattern encoding

Also means we can remove 1.8 mode conditional logic, yay!

Fixes #2317
Include -g at the start so we compile vendor/ stuff with debug symbols

This makes debugging issues in the vendor libs easier because we have
debug symbols for them as well.
Better to_string VM method for Encoding
Updated vendor/oniguruma to 3fde175c.
Update Regexp for new Onigmo types

Fixes #2370
Switch get_encoding_kcode_fallback to return an Encoding object
Start refactoring for allowing multiple compiled regexps

This is the first step to allowing multiple compiled regexps to be
cached. For example in Rails it happens very often that regexps are
recompiled all the time. This is because they are compared with
US-ASCII, UTF-8 and ASCII-8BIT strings.

This cache will have dedicated slots for these three types and a fourth
slot for other encodings which are much rarer.
Setup caching for US-ASCII, UTF-8 and ASCII-8BIT encodings

This improves Regexp handling performance by making sure we cache
potentially multiple version of compiled regular expressions for
different encodings.

This prevents large amounts of recompilation of regular expressions,
especially on things like Rails where the safe buffer handling runs
against strings of different encodings.

The performance impact of this gets heavier and heavier under concurrent
load, since now multiple threads recompile the same regexp and contend
on that. These different caches remove almost all of that overhead. This
could end up costing around 3% of total runtime on a test Rails app,
which dropped to 0.5% for matching on regular expressions.

A benchmark showing this problem improved significantly:

Before:
=== bin/rbx ===
Regexp#match on same strings
                      4462802.5 (±0.9%) i/s -   22305129 in   4.998464s
Regexp#match on changing string encodings
                       257463.1 (±6.5%) i/s -    1282537 in   5.002924s

Aftern/rbx ===
Regexp#match on same strings
                      4313785.9 (±3.4%) i/s -   21506726 in   4.992320s
Regexp#match on changing string encodings
                      1759443.4 (±0.9%) i/s -    8842288 in   5.026072s
Add benchmark demonstrating Regexp performance issue