Use enumeration type in the header

Creates nicer debugging output when printing an object header in GDB,
showing the meaning directly instead of a magic constant.

    f = {
      inflated = 0,
      obj_type = rubinius::PackedObjectType,
      meaning = rubinius::eAuxWordLock,
      zone = rubinius::YoungObjectZone,
      age = 0,
      Forwarded = 0,
      Remember = 0,
      Marked = 0,
      InImmix = 0,
      Pinned = 0,
      Frozen = 0,
      Tainted = 0,
      Untrusted = 0,
      LockContended = 1,
      unused = 0,
      aux_word = 256
    },
Fix handle initialization setup

There was a race condition when we want to inflate an object header. The
problem was occured when an object was thinly locked and then an object
id needed to be stored too. In that case we need to inflate header.

During this scenario, another thread actually unlocked the thinly locked
object. This caused the atomic replacement in
ObjectHeader::set_inflated_header to fail. This is exactly how it should
work.

The problem however is that when we attempt to set the inflated header a
second time after the failed compare and swap, we don't reset the values
derived from the original flags in the header. So the owner_id_ that was
set during the first attempt, wasn't cleared on the second attempt.

This meant that after a succesful second attempt of the compare and
swap, the inflated header had an owner_id_ set, even though the second
time the original object header was not thinly locked and had no owner
anymore.

This could cause deadlocks later on, because other threads would still
see the object as locked, but since it wasn't, nothing every unlocked it
again.

This change makes sure we reset the additional properties we track in
the inflated header each time we update the inflated header.
No need to switch on meaning

In the past, inflated was also a meaning so we had to exclude that.
Since we don't have that anymore, we don't have to guard this condition.
If we try to update a header and it fails we can retry

If we fail to update a header atomically and see an empty object header,
that's a valid state. It could be that the header was used for something
else before and isn't anymore, for example when it was thinly locked
when trying to install an object id and unlocked when the header was
swapped.

Related to #1995
Add specs for Kernel#public_methods
Fix Kernel#public_methods

The return value of Kernel#public_methods contains protected methods.

    obj = Object.new

    class << obj
      def obj_public; end
      protected; def obj_protected; end
    end

    p obj.public_methods.grep(/^obj_/).map(&:to_sym)

    # Before(invalid)
    #=> [:obj_public, :obj_protected]

    # After
    #=> [:obj_public]
Add spec for throw inside rescue and $!
Clear exception when using throw

Fixes #2001
Merge pull request #2005 from kachick/fix/kernel-public_methods_including_protected_methods

Kernel#public_methods contains protected methods 
Add specs for initialize_clone and initialize_dup
Implement initialize_clone / initialize_dup behavior

Fixes #1889, #1910
More reasonable specs for marshaling an encoded String.
Wait up to a second for a process to daemonize.
Specs for Marshal.load with encoded Strings.
Fix marshaling string encoding. Fixes #1971.
Spec for sprintf result.
Spec for String#downcase encoding.
Encode result of #sprintf and String transforms. Fixes #1977.