Add spec examples for Module#method_added
Add specs for {Kernel|BasicObject}#singleton_method_added
Fix Module#alias_method for hooking method added
Add a check for EOVERFLOW errno and adjust tm_isdst

Checks EOVERFLOW as well for retrying. This way we get correct
timestamp even for times with bogus isdst under NetBSD. Skip
the retry if tm_isdst is already 0. Restore original value of
tm_isdst if retrying also fails. Handle this way both calls
to mktime(), not just the last one.
Unify write barrier access

This ensures we only have one implementation for the write barrier.
Before Object had it's own implementation and the write barrier itself
as well.

Also removes the aux barrier mechanism for now, since we don't need it.
If we want / need it, we can introduce it again in the future.
Don't conditionalize write barrier with mature guard

This is not correct for the cases where we have concurrent marking
active. We should always use the complete write barrier and not write
short cuts in the calling code for this.
Only call the setter for auto marking if the object changes

This makes sure we don't go through the write barrier unneccessary if
the given object hasn't moved.
Don't use onig_data field for storing non managed results

This ensures that if we do concurrent marking, we don't see this invalid
state at all when recompiling. The GC still sees valid objects then and
there is no race condition here on the initialization.
Removed clear tracking since it causes compile issues
Set freed status before calling free()

This way we don't have to store the value on stack.
Simplify to check singleton class

refer: https://github.com/rubinius/rubinius/pull/2368\#discussion_r4459063
Remove fail tags for bindng
We always create a code resource as marked initially

This ensures that if we create a new code resource after the object
storing it is already marked, we don't clean it up accidentally.

This can result in the code resource to be kept alive one more GC cycle
in cases where it's immediately discarded, but this is an unlikely
scenario with code resource objects.
Initialize inflated header marks with current mark

This ensures that we always see these as used. This does result in
inflated header potentially surviving one GC cycle longer, but this is
usually unlikely for objects that get inflated.
Remove unused detach flag
Use conditional check for running write barrier
Simplify write barrier usage
Simplify inflated header setup by removing -1 state

This is possible now because we initialize the inflated header with the
current mark anyway so it's already set as in use then.
Merge pull request #2368 from kachick/fix-module-alias_method_for_hooking_method_added

Module#alias_method should call {singleton_}method_added
Different behavior of binding for 1.8 and 1.9

Ruby 1.8.x uses the receiver of #binding as self in the binding.

  Kernel.eval("self")         => Kernel
  Kernel.binding.eval("self") => Kernel
  eval("self")                => main
  binding.eval("self")        => main

Ruby 1.9.x uses the current call context as self in the binding.

  Kernel.eval("self")         => Kernel
  Kernel.binding.eval("self") => main # difference
  eval("self")                => main
  binding.eval("self")        => main

In case when we execute binding where caller is Kernel, self of binding
is 'Kernel' (this is valid for ruby 1.8). But for 1.9 self of binding
when caller is Kernel should be self from current context.

  Kernel.binding.self == self   # valid for ruby 1.9
  Kernel.binding.self == Kernel # valid for ruby 1.8

When you call #eval method, binding is created dynamically and self of
binding is in this case Kernel.