Add spec for the return value of IO#set_encoding
Return self from IO#set_encoding
Make autoload thread safe

The strategy here is to reuse the fact that require is already thread
safe. This means we keep the autoload around and when a constant is
defined, we add it to the autoload itself. Only the currently loading
thread will see that constant for code loading.

Other threads will still see the Autoload and try to load the file, this
blocking until the loading is done and continue afterwards.
Add a concurrent Module#autoload spec.
require 'thread' is unneccessary since 2.0 already provides Mutex

Also fixes a typo in the comments.

Fixes #2080
Add cache for $LOAD_FEATURES

Rubinius will create cache for require short paths. When user
require file ie:

  require 'path'
  CodeLoader.loaded_features_index => { 'path' => '/real/path' }

When we try require 'path' once again Rubinius will not travel via
$LOAD_PATH because loaded_features_index include 'path'. But when user
will try require '/real/path' Rubinius will find this feature in
$LOADED_FEATURES. In the case of not finding the file anywhere Rubinius
will try find file in $LOAD_PATH and fill in cache.

When $LOADED_FEATURES change we need to invalidate cache!
With cache all specs pass
Add spec for Enumerator::Generator to be Enumerable
Enumerator::Generator needs to be Enumerable

Fixes #2354
Merge pull request #2353 from LTe/cache-for-require

Add cache for $LOAD_FEATURES and $LOAD_PATH
Raises the original exception when #to_ary raises

When the argument is a splat, #to_ary is not called in MRI 1.9
Checks if #to_ary raises an exception

If `#to_ary` was redefined and being yielded, an crashed occurred.

Fixes it by finding every `send(state, call_frame, G(sym_to_ary))` call
in a object and checking if it is null. If it is, an exception occurred,
so we run it.

Example (see #2347):

```ruby
require 'test/unit'

class TestFoo < Test::Unit::TestCase
  def test_foo
    obj1 = Object.new
    obj2 = obj1.dup
    def obj1.to_ary
      raise
    end
    assert_equal([obj2], [obj1].flatten)
  end
end
```

Fix #2347
Update website with latest jekyll

Also updates config file for the latest jekyll version.
Add new blog article about access to call sites

This is a short blog post on how you can access call site objects from
Ruby and do more inspection of the state of the VM at runtime.
Allocate room for ruby method for proc

This ensures the JIT doesn't have to use the slow path for reading this
information from a proc.
Retrieve string data after we stop threads that could GC

This could read invalid data in c_str because that string buffer was
retrieved before handling auxilary threads. But that handling could
result in a GC which would move the pointer that c_str would point at.

By retrieving the pointer after GC'ing we make sure we have the correct
data. Also improve the error message if we fail to run `` so we have
more useful information.
Introduce File::Stat as a primitive

This was previously implemented using FFI which has some inherent
performance problems. The problem is that FFI allocates the used struct
for stat() using malloc and frees with free which causes heavy churn
because of this.

This could be aleviated by using GC managed memory for this, but
combined with how FFI currently works that would mean either having to
mature allocate the data or adding new FFI features for allowing a call
to be made without going GC independent.

Mature allocation isn't something we'd want for stat() calls since stat
objects are a perfect example of objects that often only live very short
and should be cleaned up quickly.

Introducing both GC managed memory for FFI calls using structs and
allowing FFI calls to be made without going GC independent so the
managed memory doesn't move is a big change, so taking this approach for
now is easier. We should revisit this if we improve FFI to make doing
this with FFI easier / possible. Another tricky part about stat() is how
it binds regarding 64 bit filesystems. It uses macro's for that if you
compile your app, so we had to have helpers for this already.

And now for the performance numbers of this change.

Before:
=== bin/rbx ===
           File.stat   286796.1 (±2.7%) i/s -    1447040 in   5.049272s

After:
=== bin/rbx ===
           File.stat   722130.3 (±2.0%) i/s -    3633256 in   5.033514s
Cleanup unused FFI helper functions
Only discard VM objects if they are started

There might be race where due to a previous fork these weren't
initializated yet when forking again. Therefore only try to clean them
up when they actually are set.

Also removes a useless header file and the places where that was
included.
Use same config flag for rb_gc() as GC.start