Use OTTypedInterfaceObjectHelper macro

Automatic conversion:
 * NumericalMathFunctionImplementation --> NumericalMathFunction
Automatic conversion from DistributionImplementation into Copula
Automatic conversion from DistributionImplementation into SklarCopula
New macros to convert Python sequences into Collection<foo>

The macro
  OTTypedCollectionInterfaceObjectHelper(Interface)
is expanded into:
  %template(Interface ## Collection)   OT::Collection<OT::Interface>;
  %typemap(in) const Interface ## Collection & {
    if (SWIG_IsOK(SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor, 0))) {
      // From interface class, ok
    } else {
      $1 = OT::buildCollectionFromPySequence< OT::Interface >( $input );
    }
  }
  %typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER) const Interface ## Collection & {
    $1 = SWIG_IsOK(SWIG_ConvertPtr($input, NULL, $1_descriptor, 0))
      || OT::canConvertCollectionObjectFromPySequence< OT::Interface >( $input );
  }
  %apply const Interface ## Collection & { const OT::Collection<OT::Interface> & };

This means that a function which has an argument
  const OT::Collection<OT::Interface> &
will first checker whether this argument can be converted from
its current type into this one.
Next it will check whether this is a Python sequence, and in this case
whether list elements can be converted into the right type.

The macro
  OTTypedCollectionInterfaceObjectMisnamedHelper(Interface,CollectionType)
is used when Collection type does not follow this naming pattern.

When defining collections with any of these macros, struct traitsPythonType
must be defined like this:
  template <> struct traitsPythonType<OT::Interface>
  {
    typedef _PyObject_ Type;
  };
and the following two functions must be defined:

  template <> inline bool canConvert< _PyObject_, OT::Interface>(PyObject * pyObj)
  template <> inline OT::Interface convert< _PyObject_, OT::Interface>(PyObject * pyObj)

The macros
  OTDefaultCollectionConvert(Interface)
  OTDefaultCollectionConvert2(Interface,Implementation)
are provided in order to define these functions in the general case.
If class does not follow the usual interface/implementation pattern, these
functions must be written by hand, see for instance Copula.i
Automatic conversion from a Python sequence into Collection<foo>

When defining collections with OTTypedCollectionInterfaceObjectHelper,
struct traitsPythonType must be defined like this:
  template <> struct traitsPythonType<OT::Interface>
  {
    typedef _PyObject_ Type;
  };
and the following two functions must be defined:

  template <> inline bool canConvert< _PyObject_, OT::Interface>(PyObject * pyObj)
  template <> inline OT::Interface convert< _PyObject_, OT::Interface>(PyObject * pyObj)

As Collection<foo> may be used in a different module from where it is defined,
these functions must be written into a separate file.  It had been decided to
write them into <module>Collection.i, where <module> is named after <module>TemplateDefs.i.

Then
  %include <module>Collection.i
is written into foo.i, and the same line can be inserted in xxx_module.i if this module
needs these functions in order to be compiled.
Remove dead code