stdlib: Explicitly type case procedures

With optimisation disabled we won't automatically type the (case-lambda)
clauses based on their contents. This is correct but leads to weaker
type checking. Explicitly type everything to catch more errors at
compile time with optimisation disabled
compiler: Prefer inline plans to invoke plans

If an inline and invoke plan have the same cost choose the inline plan.
This makes the inliner slightly more aggressive.

The justification is that the invoke procedure will typically end up
doing the work the inlined version would. The current costing logic only
considers the cost directly at the call site and will pick the locally
cheapest option.

For example, some (case-lambda)s are costed at 32 points each for both
calling the case clause and invoking the underlying native function
directly.  However, they both end up having to call the native function.
Calling through the case clause requires some additional unboxing inside
the case clause itself. In this case invoking the native function
directly is the most globally optimal choice.
compiler: Check the range of constant integers

Whenever converting a constant exact integer to a native integer type
make sure it will fit in the range of the target type. This is an easy
check that catches things like passing negative values for length
arguments or non-bytes to (make-bytevector).