Currently this just contains one very simple benchmark for the
morphism parser, but more will come in time.

The constant parser naively failed to parse `a10`, when the set was
`{a1, a10}`, because it would stop parsing after the 1.

Parses functor expressions of the form `X^2` with corresponding
morphisms `{0: x, 1: y}`.

The latter should in theory also be writable as a product `(x,y)`, but
that would lead to ambiguity with the product parser, so currently
you'd have to use the functor `XxX` instead of `X^2` to get that
morphism syntax.

This allows to use `1`, `55`, etc as constant sets.

Same as the parent commit: Allows to use N (or ℕ) as set.

Previously, the each constant-set had to be explicitly enumerated as a
list of strings. Now it also allows to declare Z (or ℤ) as the set and
use actual integers as constant values instead of strings.

Adds a second `Int` component to `Label Polynomial` that specifies the
index into the exponential.

The RefinementInterface class itself doesn't require that the type is
Functor, Foldable or Traversable. This constraint is now required at
the use sites where it's needed.

These are now subsumed by the polynomial functor

Allows to write a morphism for the functor `{a}` as `x: a` instead of
`x: inj 0 (a)`

This begins the implementation of the polynomial functor. It currently
only implements the morphism parser and neither the refinement
interface nor the functor expression parser. Both will come at a later
state.

This allows to parser more complex expressions in a single
functor (like the polynomial functor), instead of only unary and
binary parsers.

The downside is that implementing a functor parser got more complex:
Each functor now has to call the `inner` parser by itself and also
handle the case where the inner parser succeeds and the outer parser
fails separately.

This design doesn't sound particularly elegant, but there is no
obvious other solution.

This is only temporal and demonstrates the fact that multi-argument
functors are implementable. In the future this will be replaced by a
more general polynomial functor, but the parsing infrastructure for
functor expressions can't handle that yet.

This allows files to exists in the examples directory that don't have
a ".out" file. These are now ignored in the test suite. Such files
could be documentation or ephemeral tests.

... just to have uniform nomenclature

- Add API docs
- Make data fields strict and (if possible) unpacked
- Rename a few things for more consistency

Allow to use the unicode codepoint "LETTER CAPITAL P WITH HOOK" as
powerset functor symbol.

All files in examples/ now have a corresponding .out-file that is
checked against the algorithm's output on that example as part of the
test-suite.