Publish the most recently built linux binaries as artifacts. This makes
the wait shorter for users who just want to try copar quickly.

Also add a link to the artifacts in the readme

There seems to be no up to date docker image for GHC

Comparision with (a-b < ɛ) is not transitive and thus doesn't induce
an equality relation. Since the whole job of the algorithm is to
partition according to an equality relation, this may be problematic.

Instead, to compare doubles a and b, we now round both values to
floats and compare those exactly. This means that we get a proper
equality relation, even if it fails to distinguish some states and
wrongly distinguishes others when compared to operations on true real
numbers.

This adds a field to `--stat` output, which counts the number of times
a block is skiped instead of marked for splitting because it only has
one element. This optimization has drastic performance improvements in
some cases and the new metric can give help to attribute the run time
cost correctly.

This was there to ensure that the original block isn't put into the
queue twice, but first this can't happen anyway due to how the queue
is implemented and second, one of the new split-of blocks always
inherits the identity of the original block, making (maybeAdd b
blocks) a no-op.

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".

It's not really needed.

F seems to be the canonical name for the functor of an F-coalgebra.

Instead of a tuple of a Bool and an Int, include the Bool value in the
Int as its least significant bit.

ma -> copar

Previously we injected each state into `a`, which had to implement
`Ord`. Now the caller has to supply `(State -> State -> Ordering)` and
handle the comparision itself. This is more efficient if the caller
knows a better way than to dynamically dispatch on the Ord interface.

Note that unfortunately there is now way around the constant boxing
and unboxing of `State` values at the boundary of the higher order
function.

Fixes #1

Bools can't be unpacked as of GHC <= 8.6, because Bool ain't a
single-constructor data type.