Crank up the BDD zip limit a bit, because we're hitting it in a few
places which succeed without it.
Do a better job of suppressing uninitialised variables in the result
of symbolic execution, making sure that we kill off references in the
path constraint as well as in the terminal state itself.
Tweak the BDD pretty printer so that we assign labels in the same
order as we print the nodes.  This tends to make the labels go in
ascending order most of the time, which is a bit easier to read.
Tweak the reorder_bbdd bit of the expression eval map so that the
structures can be reused across evaluations.  This reduces memory
consumption by quite a bit.
Make a couple of changes to the wat reorder_bbdds work:

-- We now cache the bbdd<->reorder_bbdd mapping wherever possible.
-- We now do a much better job of reusing fragments of reorder_bbdd
   when the avail set changes

The result is a useful reduction in memory consumption on big CEDs.
Rejigger the reorder_bbdd stuff to reduce memory consumption yet
further.  The point here is to reduce the number of intermediate
structures which must be constructed during conversion between BBDD and
reorder_bbdd formats.
Rework GC callbacks a little so that they can be safely installed
before the heap's global constructor runs.  This means that you can
now safely have static objects which are callbacks.
Another reworking of the reorder_bbdd bits.  The big changes are:

-- Merge fix_ordering and ::Node.  This means, in particular, that we
   can merge their memo tables, which should help to further reduce
   memory usage.

-- The various caches have to get blown in a couple of places to avoid
   bad interactions with the GC.  Make that a bit more obvious by just
   redoing them as weak tables.  This means that the caches only get
   blown in precisely the places where they need to be blown, which
   should again reduce memory usage.
Better phase 0 simplifier, making much more use of the structure of
the BBDD.
Do the subst_eq thing on the sub-conditions generated for enforcement
plans, as well, since that sometimes reveals some other simplification
opportunities.
Fix some linker weirdness.
Update to handle the new BCG and types database formats.
It sometimes happens that the factorised side condition is easier to
analyse than the whole thing, allowing us to show that certain states
in the crash enforcement plan are unreachable.  Simplify when that
happens.
Remove a bad assertion.
Oops, forgot a git add.
Redo the subst_eq thing so that it always tries to make expressions
easier for the bytecode interpreter to deal with, rather than using
some other metric of goodness which sometimes helps the interpreter
and sometimes hurts it.
Rewrite the subst_eq stuff to be slightly less barking mad.
Do something vaguely sensible when asked to emit a constant validation
side-condition.  This can sometimes happen due to the different
simplification rules.
Yet another rejiggering of subst_eq.  The changes are:

-- Use quickSimplify rather than simplifyIRExpr, since that fits
   better with the BDD bits.
-- Iterate to a fixed point.
-- If we get something like 0 == x - y, treat that as x == y instead,
   because that's more likely to fire and is generally more useful.
It's not a great idea to introduce a rewrite rule for x == x.