rigidBodyDynamics/bodies: Complete set of clone functions to support copy construction and assignment

e.g. (fvc::interpolate(HbyA) & mesh.Sf()) -> fvc::flux(HbyA)

This removes the need to create an intermediate face-vector field when
computing fluxes which is more efficient, reduces the peak storage and
improved cache coherency in addition to providing a simpler and cleaner
API.

dotInterpolate interpolates the field and "dots" the resulting
face-values with the vector field provided which removes the need to
create a temporary field for the interpolate.  This reduces the peak
storage of OpenFOAM caused by the divergence of the gradient of vector
fields, improves memory management and under some conditions decreases
run-time.

This development is based on a patch contributed by Paul Edwards, Intel.

to allow the construction of vtables for virtual member functions
involving the inner-products of fields for which a "NotImplemented"
specialization for scalar is provided.

src/Pstream/mpi/UPstream.C: Cast-away const-ness for backard-compatibility with OpenMPI versions  < 1.7.4
Resolves bug-report http://www.openfoam.org/mantisbt/view.php?id=2044

applications/test/rigidBodyDynamics/pendulum: Simplified using sphere constructor and body lookup by name

rigidBodyDynamics: Added sphere body to simply construction of articulated bodies containing spheres

Resolves bug-report http://www.openfoam.org/mantisbt/view.php?id=2041

Patch contributed by Bruno Santos
Resolved bug-report http://www.openfoam.org/mantisbt/view.php?id=2042

Resolves bug-report http://www.openfoam.org/mantisbt/view.php?id=2041

applications/test/rigidBodyDynamics/pendulum: Very simple test/demonstration of the rigidBodyDynamics library

    Simple swinging pendulum simulation with 1-DoF.  The motion is integrated
    using a symplectic method for just over 2-periods.

Based on the principles, algorithms, data structures and notation
presented in the book:

    Featherstone, R. (2008).
    Rigid body dynamics algorithms.
    Springer.

This development is sponsored by Carnegie Wave Energy Ltd.

    //- Disallow default shallow-copy assignment
    //
    //  Assignment of UList<T> may need to be either shallow (copy pointer)
    //  or deep (copy elements) depending on context or the particular type
    //  of list derived from UList and it is confusing and prone to error
    //  for the default assignment to be either.  The solution is to
    //  disallow default assignment and provide separate 'shallowCopy' and
    //  'deepCopy' member functions.
    void operator=(const UList<T>&) = delete;

    //- Copy the pointer held by the given UList.
    inline void shallowCopy(const UList<T>&);

    //- Copy elements of the given UList.
    void deepCopy(const UList<T>&);

Contributed by Mattijs Janssens.

1. Any non-blocking data exchange needs to know in advance the sizes to
   receive so it can size the buffer.  For "halo" exchanges this is not
   a problem since the sizes are known in advance but or all other data
   exchanges these sizes need to be exchanged in advance.

   This was previously done by having all processors send the sizes of data to
   send to the master and send it back such that all processors
   - had the same information
   - all could work out who was sending what to where and hence what needed to
     be received.

   This is now changed such that we only send the size to the
   destination processor (instead of to all as previously). This means
   that
   - the list of sizes to send is now of size nProcs v.s. nProcs*nProcs before
   - we cut out the route to the master and back by using a native MPI
     call

   It causes a small change to the API of exchange and PstreamBuffers -
   they now return the sizes of the local buffers only (a labelList) and
   not the sizes of the buffers on all processors (labelListList)

2. Reversing the order of the way in which the sending is done when
   scattering information from the master processor to the other
   processors. This is done in a tree like fashion. Each processor has a
   set of processors to receive from/ send to. When receiving it will
   first receive from the processors with the least amount of
   sub-processors (i.e. the ones which return first). When sending it
   needs to do the opposite: start sending to the processor with the
   most amount of sub-tree since this is the critical path.

Patch contributed by Mattijs Janssens
Resolved bug-report http://www.openfoam.org/mantisbt/view.php?id=2038

Patch contributed by Bruno Santos
Resolves bug-report http://www.openfoam.org/mantisbt/view.php?id=2034

Patch contributed by Bruno Santos
Resolves bug-report http://www.openfoam.org/mantisbt/view.php?id=2032

to avoid operator resolution ambiguities when compiling single-precision