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
  OTDefaultCollectionConvertFunctions(Interface)
  OTDefaultCollectionConvertFunctionsMisnamed(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)

If Collection<foo> is used in a different module from where it is defined, this
module will fail to build:
  error: invalid use of incomplete type ‘struct OT::traitsPythonType<foo>’

These functions must then 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 is inserted into xxx_module.i if this module
needs these functions in order to be compiled.
Remove dead code