No more destructive MERGE of shared data in best-modular-version

The old code worked by accident: few/no platform implements
untagged signed modular arithmetic VOPs.

The new code handles that common case to avoid consing a fresh list
when the MERGE will be an identity.
Avoid uselessly re-scanning modular arithmetic expressions

When modular arithmetic transforms have already fired for a
subexpression, and that subexpression's width is at most as wide
as the bitwidth we're cutting to, there is no need to re-traverse
the subexpression.

There was already some code to detect that case. Make it more general,
and, more importantly, sound.
Insert explicit cut to width when needed

 When modular arithmetic operations are replaced with specialised
 modular variants, the result's bitwidth is determined by the variant,
 and might be wider than expected. If necessary, insert an explicit
 cut to the exact bitwidth before returning a value in a non-modular
 context.

 Spotted by pfdietz's random tester.

 Fixes lp#1199428.
Disentangle storage base initial size from growth increments

Before, an initial stack frame size of 8 meant that the stack frame
always grew in increments of 8. Not only is a large initial size bad
for GC (it leaves more dead references untouched), but a large increment
is even worse.
Smaller stack frames on x86oids

Start at 4 slots (for some reason, it seems that 3 isn't really
the minimum, and grows by one slot at a time.
Grow regalloc datastructures geometrically for unbounded SCs
Pack (mostly) stack TNs according to lexical scope information

 Packing TNs from shallow scopes before more deeply nested one
 is a perfect elimination order when the live ranges span the
 full scope (the interference graph is a comparability graph).
 Use that as a heuristic, and do that for TNs that are known
 to have such simple live ranges before the rest: this ensures
 that bad TNs don't mess everything up.

 The result is much tighter stack allocation (most of the effect
 comes from initialising stack frames at a smaller size, and growing
 less aggressively), and fewer long-lived stray references.

 Incidentally: fix catch block packing on win32, solving lp#1072739
Modular integer %NEGATE on x86oids

Forms like (logand (- word) word) now compute the negation in modular
arithmetic, without consing an intermediate bignum, just like integer
addition, multiplication and subtraction.

The VOPs are trivial, and should be easily added on all other
platforms, I just don't have access to build hosts.