compiler/arm/arith: More bignum VOPs, thanks to Krystof and pkhuong.

  * Original implementations by Krystof, with improvements based
on feedback from pkhuong, plus my own preferences and
interpretation of the situation.
compiler/arm/call: Actually save the LRA in MULTIPLE-CALL-LOCAL.

  * A simple oversight, we were computing the LRA correctly, but
not storing it to its passing location.  A one-line fix.

  * With thanks to stassats, who managed to nail down a fairly
minimal test case.
compiler/arm/macros: Fix LISP-RETURN to set flags correctly.

  * I had used the wrong immediate constant, as spotted by
stassats in #sbcl.
compiler/arm/call: Fix condition sense in RECEIVE-UNKNOWN-VALUES.

  * I somehow managed to switch the cases for single-value and
multiple-value returns.

  * Test-case minimization and fix-testing done by stassats.
compiler/arm/arith: Don't bit-negate the result of %BIGFLOOR.

  * It turns out that, unlike some systems, the carry flag on ARM
is such that the result comes out correctly, not inverted.
compiler/arm/arith: Use unsigned flag test in %BIGFLOOR.

  * A simple oversight, the original SPARC code was using an
unsigned comparison in its implementation, therefore we should as
well...  right?  Either way, doesn't affect the output from my
test case of (%BIGFLOOR 0 7 3), so what could possibly go wrong?
assembly/arm/arith: Implement SIGNED/SIGNED=>SIGNED/SIGNED TRUNCATE.

  * Based on the ALPHA version for the basic idea, our existing
ARM %BIGFLOOR setup for the details of actually doing the division,
and behavior-checked against a chart of results in Hacker's
Delight (Henry S. Warren, Jr., 2003) to make sure that the sign
handling was correct for all combination of input signs.
compiler/arm/call: Save outbound CFP in {,MULTIPLE-}CALL-VARIABLE.

  * A simple oversight: For tail-call our CFP gets discarded and
our caller's CFP is already in the passing (and save) location.
For non-tail, non-variable call, our CFP gets saved during
ALLOCATE-FULL-CALL-FRAME.  But for VARIABLE call, we need to save
it ourselves after loading the register args but before switching
to the callee frame.
runtime/arm-arch.c: Turns out there's another SIGTRAP generation method.

  * Found out about this one recently.  It turns out that modern
ARM Linux recognizes a specific undefined (specifically, defined
as being unlikely to be defined, similar to x86oid UD2)
instruction as a call for SIGTRAP rather than SIGILL.  We'll still
want our clever conditional SWI for PSEUDO-ATOMIC, but the single
word trap should simplify things elsewhere.
runtime/arm-assem.S: Switch undefined_tramp to the simpler trap instruction.

  * As a proof-of-principle (and saving an instruction in what is
clearly not a fast-path situation), switch from using an SWI to
trigger SIGTRAP in undefined_tramp to using the magic breakpoint
word, whatever it's called...  If it's even called anything.
compiler/arm/call: Always set CSP in COPY-MORE-ARG.

  * If we are expecting some number of fixed args, and there are
no &MORE args, we managed to not set the CSP, which would lead to
badness if the stack frame was larger than the space allocated for
inbound args.

  * Fix, by setting CSP before skipping out on the entire copying
loop.