Skeleton for TBB device adapter.

Algorithms not implemented yet.
Implemented basic schedule, scan, and sort algorithms for TBB.

The implementation is not complete (and the device adapter test fails
because of it), but it is a start.
Creating general device adapter algorithms (starting with StreamCompact)

Currently there is a major compile problem.  The general algorithm needs
to call the correct algorithm for the device adapter.  Currently the
compiler is giving me grief about not finding the appropriate symbols
for the device adapter algorithms that are implemented.

It is not totally clear to me why I'm getting problems here and not
elsewhere.  I believe the issue is that the device adapter algorithms
are implemented as overloaded templated functions.  When compiling the
generic function, it grabs the implementation of the overload that it
sees not knowing about the other overloads.  Even though the correct
overload is defined when the templated function is instantiated, it was
not in the symbol table when the templated function was first compiled.

I can think of two possible ways around this problem.  First, I could
add the functions that need to be called as template parameters to the
generic functions.  Second, I could change all the device adapter
algorithms to be inside a specialization of a templated struct.  I only
expect to do the latter if this issue comes up in a way the user can
see.
Merge branch 'HeaderOrder' into tbb

Conflicts:
	dax/cont/internal/DeviceAdapterAlgorithm.h
	dax/cont/internal/testing/TestingDeviceAdapter.h
Update TBB and General device adapter algorithms to new prototypes
Make ScanExclusive return total sum instead of last element.

This is more typical of a return value and generally more useful.
Improper schedule in general StreamCompact.
Add an implicit counting array.
Add a unit test for the general device adapter algorithms.

These tests use the serial device adapter for the core
schedule/scan/sort algorithms.
Implement general version of 2 argument StreamCompact.
Finished initial implementation of general device adapter algorithms

There are some issues.
Copy non-const portals to execution for in place operations

The ArrayHandle::PrepareForInPlace was just calling its own
PrepareForInput to pass data to the execution environment.  When using
the shared memory array manager, this did not actually prepare the
execution array for writing.

This change makes a special in place operation in ArrayManagerExecution
to make sure the data is copied to a writable array.  I'm surprised we
have not encountered this problem before.
Fix classification kernel for unique operation.
Add handling of TPL licenses.

Added a note at the bottom of LICENSE.txt that some files are third
party and have independent licenses and lists them.  The check copyright
test now also grabs this list from the LICENSE.txt file and uses it to
skip over the checking of the copyright in those files.
Add DAX_DEVICE_ADAPTER_TBB macro.
Make DeviceAdapterAlgorithmGeneral curiously recurring template pattern

This is to remove DeviceAdapterAlgorithmGeneral's direct dependency on
the DeviceAdapterAlgorithm template.  This previous dependency meant a
potential circular dependency between DeviceAdapterAlgorithmGeneral.h
and DeviceAdapterAlgorithm.h
Set up internal device configure with the exported scripts

To simplify things for external projects, the Dax configure installs
UseDax<device>.cmake scripts to set up the device.  This change uses
these same scripts to set up for the internal Dax build.

Also added the TBB configure scripts.
Remove duplicate setup.
Remove circular dependency for thrust algorithms.
Use TBB as default device adapter if configured for it.

Unfortunately, there is no way to ensure that the headers and libraries
are configured correctly.