This change allows metaclasses to provide the same copying/deepcopying functionality for class objects that class objects can provide for instance objects. As a concrete example of where this is useful, consider the following:

```
class Meta(type):
  def an_object(cls):
     return cls._a_stateful_member

class Foo(object, metaclass=Meta):
   _a_stateful_member = object()
```
If I take the above code, and I run:
```
>>>Foo.an_object is copy.deepcopy(Foo).an_object
True
```
This is already somewhat surprising. Compare it to the analogous code for an instance:
```
class Foo(object):
   def __init__(self):
      self.bar = object()

foo = Foo()
```
Which gives us
```
>>>foo.bar is copy.deepcopy(foo).bar
False
```
Even accepting this as the default state of affairs, it is quite upsetting that we cannot make a `__deepcopy__` implementation for our metaclass that will override this default behavior in the case that we have a classmember that we need to copy. Imagine e.g:

```
class Meta(type):
  def an_object(cls):
     return cls._a_stateful_member

  def __deepcopy__(cls, memo):
     return type(cls.__name__,
                        cls.__bases__,
                        copy.deepcopy(dict(cls.__dict__)))
```

I think one could reasonably expect this implementation to fix our initial problem. However, since class objects are explicitly ignored by the deepcopy and copy implementations, it does not.

Since `__reduce_ex__`, `__reduce__`, `__deepcopy__` and `__copy__` implementations have no effect on copy currently I think it's reasonable to assume there will be no implementations of these methods on existing metaclasses. To preserve the null behavior on class objects without metaclasses that implement these methods I've added an explicit check for class objects if these methods are all missing.