Do not attempt to move non-trivial objects in Variant

The `Variant` class has separate implementations for its move and copy
constructors/assignment operators depending on whether the classes it
holds can be trivially moved. If the objects are trivial, Variant is
trivial as well. However, in the case where the objects are not trivial,
special construction and copying needs to be done.

Previously, the non-trivial `Variant` defined a move constructor that
did a byte copy of the contained object and reset the right hand side
object so that it did not attempt to destroy the object. That usually
works because it guarantees that only one version of the `Variant` will
attempt to destroy the object and its resources should be cleaned up

But C++ is a funny language that lets you do weird things. Turns out
there are cases where moving the location of memory for an object
without calling the proper copy method can invalidate the object. For
example, if the object holds a pointer to one of its own members, that
pointer will become invalid. Also, if it points to something that points
back, then the object will need to update those pointers when it is
moved. GCC's version of `std::string` seems to be a type like this.

Solve the problem by simply deleting the move constructors. The copy
constructors and destructor will be called instead to properly manage
the object. A test for these conditions is added to `UnitTestVariant`.
7 jobs for kmorel/vtk-m-separate-cont-exec-variant in 0 seconds
Status Name Job ID Coverage
passed cdash-buildbot

passed cdash-commit

passed ghostflow-branch-check-master

passed vtk-m-dragnipur-osx-shared-debug+32bit_ids+64bit_coords+clang+tbb


passed vtk-m-dragnipur-osx-static-release+64bit_coords+clang+tbb


passed vtk-m-osheim-windows-shared-debug+ninja-vs-2017+tbb


passed vtk-m-osheim-windows-static-release+ninja-vs-2017+tbb