Creates a new module that exports commonly imported prettyprinter
modules, to cut down on the number of imports each module has to do.

These were originally separated because of some cyclic dependency that
is gone now. So in order to make the module zoo a bit more clear,
merge the two.

This extends the 'help list-functors' command by extensive
documentation on the syntax of functor expressions and coalgebras for
every functor.

This splits the previous stat values "refine-duration" into
"initialize-duration" and "refine-duration". The sum of those (plus
measurement overhead, etc) is still reported as "algorithm-duration".

ma -> copar

While AbsorbingPolynomial has brought down the running time in many
cases, it unfortunately required quite a bit more memory than the old
Polynomial, even though the number of states and edges was reduced.
The problem here was that:

1. The overall number of labels, weights and H1 values was _not_
   reduced, they were just moved into the corresponding type of
   AbsorbingPolynomial. The only thing saved was the `Sorted` layer on
   the inner data.

2. On the flip side, the old Polynomial implementation could use very
   memory efficient unboxed vectors for nearly everything, whereas
   AbsorbingPolynomial has to store wrapped SomeFunctor values (which
   are not unboxable).

This is now solved by being very memory conscious in the
implementation of Label, H1, H3 and Weight for AbsorbingPolynomial.
E.g we use the primitive SmallArray type instead of Vector and try to
avoid indirections introduced by Maybe or Either wrappers wherever
possible.

These are just the tests originally from Polynomial. Some of them are
failing right now.

Moves the transformations on functor expressions out of the
SomeFunctor definition. This was really conflating two unrelated
purposes and the new design is hopefully much cleaner.

There is now `MA.RewriteFunctors`, which is intended to be a
collection of rewrite rules on the functor expression, including the
existing polynomial->absorbingpolynomial one.

This currently only works for products of exactly two inner functors.

Provides a Monoid instance for (Double, max)

1. It will hold more than just the AFloat type in the futeure
2. The name AFloat is confusing anyways

This doesn't satisfy the runtime complexity requirements of the
RefinementInterface correctly, but is useful nontheless.

Those functors really require the inverse operation to perform as
required. A separate functor for monoids that aren't groups is
feasable, but would not satisfy the runtime complexity requirements.

This results in a 25% speedup overally in some cases.

This ensures hspec-discover is installed for test compilation. This is
unnecessary if the hspec-discover executable is already installed by
the build tool (stack), but that's not always the case.

This is still work in progress. At the moment, only graphviz is
available as output format and the command line interface isn't final
yet.

The main reason being that we need a newer criterion version to pull
in fixes for bugs that affected our benchmarks and the easiest way to
get that was to bump the stack resolver which incidentally also
upgrades the compiler.

The performance implications of this change are:

  - Microbenchmarks stay more or less the same, parsing benchmarks
    seem to get a little bit slower.
  - Real-World benchmarks on PRISM examples seem to get a bit faster
    overall.

This was a warning from cabal, so we better obey.

This adds an additional command `dot`, that produces a graphviz graph
of the morphism encoding of a coalgebra.