Overhaul derivatives for vectorisation and user registration

[d7919]

Overhaul of index derivatives. Designed to provide the following main advantages:

1. Possible for user registration of derivative methods.
2. Inner loop of derivative methods vectorise were possible and can be openmp parallelised.
3. Reduction of duplicate code.
4. More consistent treatment of staggering in all directions and for both field types.

Also provides the following minor changes:

1. More robust treatment of enums in boutcore processing.
2. uppercase routine.
3. Adds a direction enum class, a staggering enum class and a derivative class (standard, upwind, flux etc.) enum class.
4. A couple of minor helper routines have been added to mesh to provide methods to request the number of points/guard cells in a particular direction.
5. Performance examples for measuring the cost of DDX, DDY and DDZ with various supported methods.
6. Provide an overload for top level derivative methods that takes a std::string instead of a DIFF_METHOD enum. This is required to allow for user registered routines. The std::string methods should be preferred and the DIFF_METHOD overloads may become deprecated.
7. Provides a templated minus and plus offsetting routine for SpecificInd which provides a simple way to offset in a requested direction with compile time information that works nicely with routines templated on the DIRECTION enum class.
8. Adds a fourth option to mesh:dd?, currently C2 is the only valid predefined option.

Still to do:

1. Documentation. (main user documentation added, no developer docs added yet but hopefully source documentation covers this).
2. More testing. (never ending task! Basic unit testing for derivative store and template combination code added)

Main implementation details:

1. To achieve vectorisation for the "inner loop" we had to remove the function pointer indirection,
   meaning we have to effectively create an instance of the loop for every possible method and with all possible combinations of staggering, direction etc. This is achieving using some templating routines (in include/bout/template_combinations.hxx) which can do "something" for a cartesian product of options.
2. The "something" in 1. is to create derivative instances and register them in a singleton derivative store (one for each field type). This store can register routines and can return these at runtime given user options etc.
3. All the indexDD? routines now just call a single kernel (indexStandardDerivative) that gets the requested method and applies it in the appropriate direction. All the indexVDD? and indexFDD? routines now just call a single kernel (indexFlowDerivative) that gets the requested method and applies it.

The performance examples suggest that most derivative methods now vectorise, giving performance comparable to direct hard-coded nested loop. Whilst this is around a factor 3-4 improvement over the current implementation in next this is not reflected in physics models due to the other costs involved in a full model.

Compilation of the library is likely to be slower due to the template combination expansion that must be done at compile time.

[ZedThree]

Looks good, a few minor comments!

[ZedThree]

Should we namespace some of the new things? The template combo stuff might go in one, though I've not got a name to mind. Possibly bout::utils?