This allows a more flexible implementation for the functor-expression
parser and other conveniences.

This commit doesn't remove the old types but temporarily adds new ones
with a different name. This is to simplify the transition to the new
types.

This means that "names" (e.g node labels for FixedProduct) are now
parsed with the `lexeme` combinator (which consumes trailing
whitespace).

This improves parser errors by a wide margin, but requires all functor
expressions to be distinguishable with one token look ahead. This is
currently the case, but we may need to reconsider this issue.

This should reduce the build time in CI drastically.

Switches from X^G to G^X. The former would have been the syntax for a
mapping from the monoid, not into the monoid...

Unfortunately, moving the GHC-extension declaration to the cabal file
broke our doctests...

We now try to parse each functor and backtrack if necessary. This
allows individual functors to begin with the same symbol.

I use some extensions so often that it's tedious to put them into each
individual file.

This switches the parser for functor expressions (not yet morphisms)
from a YAML based one to a custom one, making those expressions much
more readable and giving individual functors greater flexibility to
define their own syntax.

processQueue was missing a 'while' loop around everything. With this,
the algorithm computes the correct result for example/example.yaml.

Yeah... leaving FIXMEs in the code and wondering why it doesn't
work.

The refinement algorithm is now complete, but (of course) sill buggy.

This will be used to return the final result of the overall algorithm.

They are needed by both 'Partition' and 'RefinablePartition' types.

This represents an immutable partition of states into blocks.

This is the function that threads each queue element through split
until the queue is empty.

Everything should be Queue-ready now.

This adds queue awareness to the initialization phase of the algorithm
and adds all initial sorted blocks into a global queue.

This check was previously done in the lumping algorithm and the
BlockQueue implementation itself would just silently fail if the check
wasn't done. Now it's moved to a more appropriate place.

A queue for sorted blocks that has O(1) membership test, enqueue and
dequeue.

The type `h` was only needed to make instance resolution unambiguous,
but type application can do that, too.

This completes phase 3 of split(). What's left is the queue handling
and actually testing the code (which isn't possible until the queue is
implemented).