* Document divergence evaluation code
* Add support for directly passing a tree path to `testFunction()` and `trialFunction()`
* When adding integrated (bi)linear forms this is now reflected in
  the assembly code by integrating those terms separately. This has the
  advantage, that different quadrature rules can be used for different terms.
  Example: While `integrate(u*v + dot(grad(u),grad(v)))` uses a single quadrature
  rule for the whole expresion, using `integrate(u*v) + integrate(dot(grad(u),grad(v)))`
  will use separate rules for both terms.

`FieldVector<K,n>{0}` leads to aggregate initialization
which only initializes the first entry in contrast to
`FieldVector<K,n>(0)` which calls the constructor
that properly initializes all entries.

* Implement more cases for `operator*` and `dot`.
* Make cache a (non-static) member of the local assembler.
  This allows to do thread-parallel assembly, if the local
  assembler is thread-local. Before this patch, the static
  cache member was shared among threads which leads to concurent
  read/write access.
* Add utility to reconstruct the global basis. The local assembler
  may need the global basis. Using this utility it can be extracted
  from the forms (that already know it) and does not need to be
  passed to `integrate(...)` separately.

This allows to uniformly handle linear transformation
of raw values and forms.

* Move handling of raw values to generic `productForm` function
* Unify handling of raw values by wrapping them into forms
* Guard `operator*` using concept check to avoid that is
  activates `Dune::dot` and thus leads to ambiguity

The `tuple`-specific version leads to shorter error messages
compared to the generic `Hybrid::forEach` implementation.

This solves a nasty ambiguity problem without
having to qualify the call to `Forms::dot`:

The `Dune::dot(a,b)` function from `dune/common/dotproduct.hh` is
based on `operator*` and SFINAE-removed from the overload
set if `a*b` is not a valid expression. Hence if `operator*`
is available for forms, the `Dune::dot` function is available
and leads to ambiguity. By disabling `Forms::operator*` for
non-supported types this is avoided, because `Dune::dot` no longer
exists.

* Provide forward declarations for dot-overloads
* Explicitly qualify internal calls to dot

We only allow local coordinates and the type is easily accessible.
Hence we can avoid making it a template of `operator()`.

We never use ternary product. Hence we can split the implementation
into the product of two forms and a transformation of a single form.
While this introduces some code duplication, it increases clarity
and avoids a lot of `tuple` and variadic template code.

Since forms always use a treepath wrt the root basis,
we have to obtain the root LocalView and pass it to
the bind methods to guarantee that tree paths are
interpreted correctly.

Drop benchmarks integrating components of a power space separately.
This is now done automatically.

This significantly improves performance in such cases.

BEnchmark is now done in a separate executable

* Implement distributive law
* Implement transposing and operator-
* Support generic products
* Add some documentation
* Put more use examples into comments of examples:
  * Sum of linear- and bilinear forms
  * Constant and non-constant coeffients
  * Linear elasticity