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.
Merge branch 'scheduler_infastructure'