Scheduler now uses tag dispatching to call the correct algorithm.

Instead of having a really messy implementation of scheduler that
spanned three files and required very special enable_if constructs,
we move to a tag dispatching system.
Implement the default scheduling algorithm based on tag dispatch.

We have refactored the default implementation to now work
in the tag dispatching system. Instead of the previous two
header file implementation I have moved to a single file.
Also new is better user argument checking and moving
the CollectCount and CreateExecutionResource classes
to different header files, as they are shared classes.
Implement a custom scheduler for the GenerateTopologyTag.

The generate topolopgy scheduler needs to do handle alot more
thinks than the default scheduler. Mainly it requires two topologies
be present and support for the use of the VisItIndex exec argument.
Introduce ability to choose scheduler based on worklet type.

DetermineScheduler determines at compile time what scheduler tag
is best option for each worklet. For each scheduler type we
implement a class that determines if it can schedule a given
worklet type. To determine which of scheduler is choosen, we
add all these choices to a mpl vector and extract the first
scheduler that returns it can execute the worklet type.

This solution was choosen because it is really easy to extend
the vector to  support more worklets, unlike using mpl::if_
which is incredibly hard to read when you have multiple levels of
nested if's.

This form of vector and ranking could be used to implement a
multi step scheduler, or a system where scheduler rank how well
they support a worklets requested arguments, etc

The other thing important part of this design is that the default
scheduler always states that it can schedule every worklet, so
it must always be the last scheduler in the vector as it
is the fail safe and if it is infront of specialized schedulers
we lose the entire purpose of this class.
CollectCount and CreateExecutionResources get distinct headers.

The classes can be used by any scheduling algorithm, so rather than
have them inside the default schedulers header, we make them
distinct files so we reduce possible header includes.
AddVisitIndexArg generates visitindex field and new cont sig.

The VisItIndex exec signature requires the control signature
of the worklet to be extended to include an extra field. The
reason for this is that only items that relate to a control
signature argument are uploaded to the exec env, and accessable
in the exec env.

The visitIndex is an exec signature only placeholder, so therefore
to get it too work properly we have to modify the control signature
of the users worklet. Actually modifying the signature is impossible,
so we inherit from the users worklet and set the derived worklets
signature to have the extended signature.

To simplfy the code in ScheduleGenerateTopology, every generate
worklet is extended with VisitIndexArg. The trick is that when
the user doesn't explictly request the argument we only upload
a single constant integer value instead of a real array so we
impart zero overhead when we don't have a request for the visitIndexArg.
Update the CMakeLists and remove unused worklets.
VerifyUserArgLengths verifies worklets are called properly.

VerifyUserArgLengths verifies at compile time that worklets
are called with the exact number of arguments they requested in the
control signature. This is a unique class so that each scheduling
algorithm can reuse the code.

We remove the original implementation from Bindings.h as
it wasn't as clear to users when reading the assert message
why it was happening. Now with it in the scheduler and
with the added comments it should be very easy to understand
why they are getting the failure.
Add infastructure for scheduling unit tests.
Add in a test to verify AddVisitIndexArg works properly.
Add a test that verifies that collect count is working properly.

Collect count always returns the length of the longest argument. So we
verify that arrray handles length is returned in comparison to a constant
value argument.
Add a test that verifies that CreateExecutionResources works.

We want to verify that CreateExecutionResources is creating exec
side objects, and that those objects are getting the correct length.
Adding a test to verify the DetermineScheduler class.
Add a test to verify VerifyUserArgLength works properly.

We Verify that the NotEnoughParameters and TooManyParamters
member types are correct under each use case of the class.
Make Vector# and Id3 typedefs instead of subclasses.

Rather than have separate Vector and Id3 classes that subclass Tuple,
make specializations of Tuple for these counts and typedef these
symbols.  This gets around potential problems with converting between a
Vector and Tuple, which are really the same thing.

One downside of this change is that error messages will now always
report Tuple<float,3> instead Vector3, for example.  Another is that
template resolution is a bit more fragile.  The compiler had problems
determining the correct version of the == operator when using some funky
iterators.
Make all VectorTraits specialized.

Rather than have a generic VectorTraits that assumes that all
unspecialized classes have the same accessors as Tuple, make an
undefined prototype and a partial specialization for Tuple types.

One big advantage of this approach is that if VectorTraits is used on
something that is not really a vector (which is common when template
parameters get messed up), you get an informative warning that
VectorTraits<class> is not defined, rather than some odd warning about a
random class missing the [] operator or something like that.
Break meat of VectorTraits test into header file.

This is so that if a vector-like class is defined elsewhere with a
VectorTraits specialization, it can be tested using the standard
VectorTraits code.
Automatic const versions of VectorTraits and TypeTraits.

Added a partially specialized version of VectorTraits and TypeTraits
that automatically provides an implementation for any const version of a
type defined by a different specialization.
Merge branch 'CleanupVectorClasses'
CMAKE_COMPILER_IS_CLANGXX wasn't always being set correctly on macs.