It's just more descriptive. The "A" did stand for "approximate", but
only the new Eq instance is approximate, so having that instance is
really the important difference from regular doubles.

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

This will be used by a new MonoidValued functor for Complex.

There has been a long-standing bug, that we only used exact comparison
for IEEE floating point values. This patch implements a newtype
ADouble that wraps `Double` and implements `Eq` approximately using
the library `ieee754`.

This makes lexer combinators like `colon` or `parens` a little faster,
which adds up for large inputs.

This cleans up newline handling in the whitespace parser:

Newlines are not treated the same as other whitespace any more and are
only allowed after the functor expression and between individual
morphism points.

By doing this, we get a less surprising grammar for parsing ("x: { y:"
would never try to parse the "y:" as the start of a new definition)
and can speed up the hot path (a single space character) considerably.

By reimplementing the float parser, we can get a considerable speedup.
This is due to the fact that we don't handle scientific notation among
other things.

By reimplementing the version from Megaparsec, but specializing to Int
and Text, we can get 6x speedups in some cases.

`L.signed L.decimal` now has minimal overhead over L.decimal on it's
own. We did sacrifice the possibility to write a (redundant) `+` sign
or white space between the minus and the number.

This already improves the parser benchmark by a factor of two.

'#' starts a line comment and skips the rest of the line.

Instead of expecting `ParserT` to be at the top of the monad stack,
they now only assume that the monad satisfies the `MonadParser`
constraint, allowing to use them unlifted in `StateT Parser`

This is still not final and has several API problems. E.g implementing
ParseMorphism for SomeFunctor is currently not possible without a
warning about unimplemented methods.

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

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.