Implementation of Module#prepend

Ruby 2.0.0

```ruby
module M; end

class C
  include M
end

C.ancestors # => [C, M, Object, Kernel, BasicObject] 

class C1
  prepend M
end

C1.ancestors # => [M, C1, Object, Kernel, BasicObject] 
```

This is only partial implementation of this feature. I don't know how change superclass chain. I found in Rubinius code. In this case we need create root for ```IncludedModule```

```C
  void test_object_class_with_superclass_chain() {
    Module* mod = Module::create(state);
    Class* cls = Class::create(state, G(object));
    Object* obj = state->new_object<Object>(cls);

    /* This should be functionally correct but not actually the
     * way a superclass chain is implemented. However, it doesn't
     * require that we create a root for IncludedModule.
     */
    Module* m = cls->superclass();
    cls->superclass(state, mod);
    mod->superclass(state, m);

    TS_ASSERT_EQUALS(cls, obj->class_object(state));
  }
```

In MRI implementation each ```RClass``` have **origin** field. On start **origin** points to itself. But after prepend interpreter allocate memory for new class and create another. 

```C
origin = class_alloc(T_ICLASS, klass);
RCLASS_SUPER(origin) = RCLASS_SUPER(klass);
RCLASS_SUPER(klass) = origin;
RCLASS_ORIGIN(klass) = origin;
RCLASS_M_TBL(origin) = RCLASS_M_TBL(klass);
RCLASS_M_TBL(klass) = 0;
```

So **klass** is still on top but have new origin. Little tricky for me :)

Someone can help me with ```Module#prepend``` implementation? Maybe Rubinius internals are not ready for ```prepend```. Any advice appreciated.