rename meta to singleton class

seems more appropriate, as it is the class for a single object
Also seems to be called that on the net (don't remember where the meta came from, but it's gone)

lib/parfait/behaviour.rb

@@ -1,12 +1,12 @@
 module Parfait
-  # Behaviour is the old smalltalk name for the duperclass of class and meta_class
+  # Behaviour is the old smalltalk name for the duperclass of class and singleton_class
   #
-  # Classes and meta_classes are in fact very similar, in that they manage
+  # Classes and singleton_classes are in fact very similar, in that they manage
   # - the type of instances
   # - the methods for instances
   #
   # The main way they differ is that Classes manage type for a class of objects (ie many)
-  # whereas meta_class, or singleton_class manages the type of only one object (here a class)
+  # whereas singleton_class, or singleton_class manages the type of only one object (here a class)
   #
   # Singleton classes can manage the type/methods of any single object, and in the
   # future off course they will, just not yet. Most single objects don't need that,

lib/parfait/class.rb

@@ -17,7 +17,7 @@
 module Parfait
   class Class < Behaviour
 
-    attr_reader :name , :super_class_name , :meta_class
+    attr_reader :name , :super_class_name , :singleton_class
 
     def self.type_length
       6
@@ -30,7 +30,7 @@ module Parfait
       super(instance_type)
       @name = name
       @super_class_name = superclass
-      @meta_class = MetaClass.new( self , self.type || @name)
+      @singleton_class = SingletonClass.new( self , self.type || @name)
     end
 
     def rxf_reference_name

lib/parfait/singleton_class.rb

@@ -1,20 +1,20 @@
 #
-# In many respects a MetaClass is like a Class. We haven't gone to the full ruby/oo level
-# yet, where the metaclass is actually a class instance, but someday.
+# In many respects a SingletonClass is like a Class. We haven't gone to the full ruby/oo level
+# yet, where the singleton_class is actually a class instance, but someday.
 
 # A Class in general can be viewed as a way to generate methods for a group of objects.
 
-# A MetaClass serves the same function, but just for one object, the class object that it
-# is the meta_class of.
+# A SingletonClass serves the same function, but just for one object, the class object that it
+# is the singleton_class of.
 # This is slightly different in the way that the type of the class must actually
 # change, whereas for a class the instance type changes and only objects generated
 # henceafter have a different type.
 
-# Another current difference is that a metaclass has no superclass. Also no name.
-# There is a one to one relationship between a class instance and it's meta_class instance.
+# Another current difference is that a singleton_class has no superclass. Also no name.
+# There is a one to one relationship between a class instance and it's singleton_class instance.
 
 module Parfait
-  class MetaClass < Behaviour
+  class SingletonClass < Behaviour
 
     attr_reader :clazz
 
@@ -36,7 +36,7 @@ module Parfait
     end
 
     def inspect
-      "MetaClass(#{@clazz.name})"
+      "SingletonClass(#{@clazz.name})"
     end
 
     def to_s