Split Python module initialization function out

The module initialization function has always been put into the Python
module itself which is marked as a MODULE in add_library in the VTK
wrapping macros. CMake disallows linking directly to a MODULE, so if
something external to the bindings want to use the module initialization
function, they don't have access to it.

To fix this, the module method is placed in an OBJECT library which can
be linked against to get access to the init function. In addition, the
code which loads each class into the module is moved into the PythonD
library. The Python module itself doesn't use the object library since some
generators do not support targets with only objects from other targets.

This is mainly intended for use in ParaView so that the Python bindings
for classes may be used to implement the ClientServer wrappings with the
Python wrappings instead of generating a second set of bindings.

Change-Id: I8dd2eb672a3b038dedafa79cae271b88fad06082
Properly hide the subclass from the wrapping code

Other code as tried to follow the pattern used in VTK for masquerading
one class as the superclass instead of another for wrapping purposes.
Unfortunately, the way VTK does it isn't a good example since
vtkDataArray is actually a special case in the parser VTK uses for
generating the bindings. Using the __WRAP__ symbol the wrapping code
defines is a better way of handing this.

The wrapping grammar is also updated to not tokenize vtkDataArray.

Change-Id: I9dd9b2d8d3b98c70e3c1542608690ead46355203
Set flags in Python for static and bound methods

Given the following Python class:

    class Example(object):
        @staticmethod
        def static():
            pass
        def method(self):
            pass

the following is true:

    >>> type(Example.static)
    <type 'function'>
    >>> type(Example.method)
    <type 'instancemethod'>

However, in CPython, all methods implemented in C and bound to a type in
C code, print the following:

    >>> type(some.c.class.static)
    <type 'builtin_function_or_method'>
    >>> type(some.c.class.method)
    <type 'builtin_function_or_method'>

so it isn't possible to tell whether a PyCFunction is a static method or
not without actually being in C code. This is done by setting the METH_STATIC
flag on static methods.

Also, using METH_VARARGS rather than '1' is better anyways.

Change-Id: Iab61d26af36c0a6b7a2360dc41c58efaf5dd40b1
Merge topic 'unified-bindings' into master

3b3dada2 Set flags in Python for static and bound methods
590e9cf6 Properly hide the subclass from the wrapping code
989050fa Split Python module initialization function out