Teach the JIT a better version of check_frozen

This optimizes for the common case of either a non reference or a not
inflated header for a non frozen object. This can be determined by a
check against the object headers, otherwise fall back to the complete
code.

Also introduce defines for the header bits. These can be used instead of
magic constant values inside the JIT.
Explicitly check first whether we have dynamic locals
Add fixnum_xor to the JIT
Add JIT primitive for Regexp.set_last_match
Fix warning with GCC on Linux
Exclude bootstrapping Melbourne build from installs.
Use Float value offset instead of magic number 1
Add annotations for methods that don't modify state

This also includes methods that might have side effects (such as
allocating an object), but that has no observable behavior from the VM
perspective.
String#initialize_copy can be empty by default

This was used for String#dup, but that method already takes care of
properly setting up the string. Therefore String#initialize_copy does
not have to be a copy of String#replace.
Setup specific allocators for String

Right now the JIT can't handle super() calls yet. This let to the
allocator for String to never be JIT'ted. For now we use these specific
allocators. In the future we should teach the JIT about super() (at
least for simple cases like this), so we can remove these specifics
then.

Also sets up Character like we setup the other internal VM classes.
Add primitives for ByteArray#set_byte and ByteArray#get_byte

Also adds primitives for Fixnum#add and Fixnum#sub. These two could be
used in certain cases where the compiler doesn't transform them to
meta_op_send_plus, such as for example the case of a[1] += 1.
Use explicit Int8Ty instead of pointer type

This apparently doesn't work in older LLVM versions.
Simplify constructor for Rubinius::ByteArray

We don't need initialize calls with blocks for ByteArray. This allows
for the JIT to inline it properly, since push_block is an instruction at
the moment that blocks being able to inline a method.
Remove Module#case_compare primitive

Using Ruby code here works just as well and also allows better inlining
and optimization by the JIT.
Performance improvements for String#gsub

Biggest change here is that originally there was a != check against
undefined. In 1.9 mode, this results in using BasicObject#!, which ended
up in String#==, where the primitive would fail for undefined.

That would trigger the fallback path and try other things such as
coercions before finally resulting in false. This changes the code so it
doesn't unecessary go down that path.
Upgrade to latest Delegate for 1.8 and 1.9

Fixes #2104
Add benchmarks for frozen?, tainted? and untrusted?
Teach the JIT about frozen, tainted and untrusted

For regular objects, we can read the status of these directly from the
header, so we don't need to call a method for those cases.
Improve performance of String#gsub in 1.9 mode

Biggest improvement comes from keeping byte based offsets so we don't
have to compute byte to char and char to byte conversions all the time.
Also makes the algorithms for 1.8 and 1.9 mode much the same, since the
1.8 version was quite a bit a faster.
Use proper type for zero comparison