Add 'fluent interface' for visitor construction

This allows to create a visitor using lambda expresions.
In contrast to a pure method call providing callbacks
this has some benefits:

* It simplifies the `Visitor` approach instead of creating
  a new traversal mechanism. Hence you still have the full
  flexibility of the `Visitor` approach.
* Instead of positional arguments you have named arguments
  which is far less error prone.
* You can use the existing mechanism to switch traversal types.
* You can easily extend visitors.

As far as I remember this design pattern is called 'fluent design'.
Here we use the piping syntax which was popularized by range
adaptors from C++20 (and ints prototype in range-V3). Usage example:

```cpp
int counter = 0;
auto visitor = makeVisitor()             // create default doing nothig
  | pre([&](auto&&...) { ++counter; })   // extend by pre callback
  | leaf([&](auto&&...) { ++counter; }); // extend by leaf callback
applyToTree(tree,visitor);               // traverse tree to count all nodes
```
7 jobs for feature/lambda-visitor-construction in 1 minute and 52 seconds (queued for 2 seconds)
latest
Status Job ID Name Coverage
  Test
passed debian:10 clang-7-libcpp-17 #140676
duneci

00:01:42

passed debian:10 gcc-8-noassert-17 #140675
duneci

00:01:45

passed debian:11 gcc-9-20 #140674
duneci

00:01:52

passed debian:9 clang-3.8-14 #140678
duneci

00:01:40

passed debian:9 gcc-6-14 #140677
duneci

00:01:28

passed ubuntu:16.04 gcc-5-14 #140679
duneci

00:01:30

passed ubuntu:18.04 clang-6-17 #140680
duneci

00:01:49