A pattern that we have been manually implementing in quite some places!

This is not used anymore since we have mixins.

In many places we treat this as codegen-time information anyway.
For loopy, this is the necessary way to go.

The SumfactKernel object stores a tuple of transformations that will be
registered in the realization and applied in the localoperator. These
transformations can change the name of the sum factorization kernel
function. This way it should be possible to use autotuning for picking
transformations.

This onleiner makes my richards example faster by 70%.

We can disable sum factorization on boundary integrals.
This commit allows us to use a different mixin for those integrals.

Introduce different methods for realize_input/output
realize_direct_input/output and setup_input/output. The setup methods cover
code generation outside the sumfact kernel function (creating input array or
accumulating result). realize and realize_direct handle the input/output in the
nonfastdg and fastdg code branch.

Seperate interface methods make it a lot easier to find out where each of those
methods will be applied. Besides that most interface classes need to provide
more that two of those methods anyway...

Non-fastdg: Permutation of the input happens before the sum factorization
kernel when we setup the input. This is done by a method of the corresponding
interface class.

Fastdg: In this case the input will always be ordered according to x,y,... This
means the permutation needs to happen in the sumfact kernel. Since we want to
vectorize sumfact kernels with different input permutation in an upper/lower
way we need to do this permutation in the corresponding interface class. This
is done in the realize_direct method and in the vectorized case the
corresponding methods of the scalar sumfact kernels are called.

Note: They are not yet used but in the long term the permutation should be
handled here since it is about input/output setup.

Note: Not yet working for gmsh files

Calculate the evaluation and jacobians of geometry mappings of cells
using sum factorization. By avoiding all geometry mapping of intersections
we can avoid the face-twist problem and just make the grid consistens (not
yet done).

TODO:
- Make grid consistent
- Vectorization
- 3D