Optimize TYPEP of (MOD X) on x86/x86-64.

Optimize type-tests in the same vein as type-checks previously, and
implement type-checks by means of type-tests. Further optimize it by
avoiding doing fixnum tests on known fixnums and boxing of
signed/unsigned numbers.
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.
1.1.10: will be tagged as "sbcl-1.1.10"
Microoptimize type-tests on x86oids.

On x86-64 in %test-lowtag instead of doing:

MOV EAX, ECX
AND AL, 15
CMP AL, 15
do
LEA EAX, [RCX-15]
TEST AL, 15

Which allows to save one byte.

On x86 this optimization is already applied, but since LEA loads a
32-bit integer, EAX can be later used as an already untagged pointer
in %test-headers: MOV EAX, [ECX-7] => MOV EAX, [EAX], which takes one
byte less to encode.
Optimize (unsigned-byte 32/64) type tests on x86oids.

Instead of doing
TEST CL, 3
MOV EAX, ECX

do
MOV EAX, ECX
TEST AL, 3

AL has shorter encoding and can save 1 byte with ECX or 4 bytes with
ESI, which doesn't have SIL on x86.

Also revert a part of the previous commit which used untagged
pointers, which can cause problems with the GC.
Microoptimize comparisons with 0 on x86oids.

Implement the common idiom of using TEST REG, REG in place of CMP REG,
0, saving 1 byte, for fast-if->/< VOPs.
In NODE-CONSERVATIVE-TYPE, ignore refs without an associated LVAR

TODO: before this can be committed for real, I have to understand what
is going on there.
LVAR-USES -> PRINCIPAL-LVAR-USE in LVAR-TYPE-USING

TODO: check whether this is correct
Add CHECK-{PROPER-LIST-OF-LENGTH,LIST-OF-LENGTH-AT-LEAST} with source transforms

These two functions check lists like
{PROPER-LIST-OF-LENGTH,LIST-OF-LENGTH-AT-LEAST}-P but return the
checked list and signal an error upon length mismatch and have
associated source transforms which turn them into noops iff matching
lengths can be proved at compile time.
rewrite PARSE-DEFMACRO machinery

In src/code/parse-defmacro2.lisp for now.
TODO temp commit: DOCUMENTATION for lambda list sections?
TODO temp commit: use new lambda list parser in src/compiler/parse-lambda-list.lisp?