Aren't dynamic inheritence changes possible in Ruby classes?

I was wondering if it was possible to make a class change superclasses dynamically - something which would allow us to make class inheritance behave along the lines of Javascript's prototype chain, perhaps. To clarify, something along the lines of

class A
  def something
  .
  .
  end
end

class B
  def someother
  .
  .
  end
end

B.inherits_from(A)

The idea being we insert a superclass into the inheritance chain dynamically.
After digging around a bit, I found this thread at the Ruby archives which says it isn't possible. The last mail on the thread demonstrates how to do it in Python, though :D. Here it is:

class Base(object):
    def meth(self):
        print 'called B.meth'

class Mixin1(object):
    def meth1(self):
        print 'called meth1'

class Mixin2(object):
    def meth2(self):
        print 'called meth2'


class C(Base, Mixin1):
    pass

c = C()

c.meth()
c.meth1()

C.__bases__ = (Base, Mixin2) # change the base classes (ick!)

print [methname for methname in dir(c) if methname.startswith('meth')]

c.meth()
c.meth2()
c.meth1() # this gives an error now

However, while that avenue is closed to us, we are still free to make use of extend and include in combination with class_eval to enhance a class and its instances respectively at runtime by adding modules - but removing the module after isn't possible. A quick example.
First, let's create a module for us to extend.

module Sneak
  def sneak_me
    return "snitch!"
  end
end

Then let's meddle with some class, say String.

String.class_eval{
  extend Sneak
}

We can now do String.sneak_me - the methods of the module have been added as class methods (or static methods, if you prefer) by executing the code in that block in the context of the class. Sort of like having

class String
  extend Sneak
end

but only at runtime.
Now to change all instances of String.

str = String.new("!")
str.respond_to?("sneak_me") # -> check if str has this method. Returns false.
String.class_eval{
  include Sneak
}
str.respond_to?("sneak_me") # -> Now returns true.
puts str.sneak_me # -> prints "snitch!"

So using include and class_eval we added a module to all instances of String, including str which we'd instantiated before actually including the module.

You may also want to read: Object Oriented and Functional: Is there a middle ground?