bootstrap:types: do_typ_create_ungenarg_update_genargs: skip when unneeded
bootstrap:passfwd: find_scope_for_name: fix for global let

Their scope is MODULE_BODY, not a BLOCK
bootstrap:passfwd: propagate constant: fix DEFNAME expression extraction
bootstrap:scope: a field named 'x' shouldn't hide a global name 'x'

	let x = 42:I32
	struct a =
		x	:I32
	a met Foo = I32
		return x

While type_inference_ident() did detect that 'x' wasn't being accessed
through 'self' (and reported an error, see old t00/bad15.n), the correct
behavior is to skip the definition in the scope of 'a' (because x isn't
accessed through a binary accessor on self) and continue the lookup in
the surrounding scope.
bootstrap:passfwd: ID_TBI_* refer to DEFINTF or DEFTYPE

This fix lets us define a method named Bool or I32.
lib/n/builtins: 1: adopt the clearest integer conversion operation names (yet)

In this patch, we rename the old To_i32 ops as I32.

	NAME		| WHAT			| ALWAYS AVAIL?		| CAN FAIL?
	------------------------------------------------------------------------------------
	x.I32		| Safe conv		| No			| No
	x.To_i32	| Risky checked conv	| Yes, unless Safe is	| Yes (assert)
	x.Try_i32	| Safe checked conv	| Yes, unless Safe is	| Yes (returns Error)
	x.Signed	| Risky checked sign c	| Yes, unless Safe is	| Yes (assert)
	x.Try_signed	| Safe checked conv	| Yes, unless Safe is	| Yes (returns Error)

The functions Safe_convert, Convert, and Try_convert in builtins are
still meant at the best way to handle generic `Integer arguments.
n/builtins: convert functions: all-purpose integer conversions (useful in generics)

Our naming conventions for integer conversion operations are meant to be
explicit in what they do: whether they are safe or may assert on range
error.

A generic such as
	(fun t:`Integer u:`Integer) add x:t y:u = t
		return x + y
cannot be easily defined in terms of conversion operations (one cannot
simply do a cast to (t) on both operands, like one would in C++). The
methods to use depend on t and u.

	(fun t:`Integer u:`Integer) add x:t y:u = t
		return x + (Convert t) y
	(fun t:`Integer u:`Integer) add x:t y:u = t
		return x + (Force_convert t) y

are two possible definitions using the convert family of functions. They
have different semantics: the first will assert on range error. The
second will reinterpret and extend/trim the bit representation.

Try_convert returns an error on range error.

Safe_convert is only available for type pairs that can safely be converted.
	Safe_convert I16 U8 -- is available
	Safe_convert I8 U8 -- is not available
The second form results in a compilation failure.

Only Force_convert is implemented yet.
lib/n/builtins: 2: integer conversions: add missing safe converions (e.g. U8.I16)
lib/n/builtins: 3: floating conversions: adopt similar names to integers; limits
lib/n/builtins: 4: add comment on the lack of Bitwise_ ops for Uint/Int
bootstrap:passfwd: global constant propagation: disable SSA
lib/n/builtins: fix stupid inversion MIN/MAX values for signed integers
bootstrap:cprinter: stop casting numerical constants to their concrete type

We thought the approach of converting
	let x:I32 = 1 * 2 + 3 / 4
into
	let x:I32 = 1:I32 * 2:I32 + 3:I32 / 4:I32
was sensible and would make it easy to track overflow/underflow, etc.

But in fact, this turns out to be entirely misguided.

A case such as
	fun foo = I8
		return -0x80
which gets effectively transformed into
	fun foo = I8
		return -(0x80:I8)
illustrates how naive the idea is. 0x80:I8 overflows... Even though the
function definition is perfectly fine.

Instead of fixing this particular case, we're coming to the conclusion
that Go probably got it right all along: perform all numerical
computations on constants with unlimited precision, then convert to the
final concrete type, checking for overflow only then. We will probably
adopt a similar strategy down the road. TODO

In the meantime, all integer constants are printed with the postfix LL
and no type conversion. This isn't ideal either, but works in more cases
and is more like C.
tdiff: add support for .go reference file (run it, compare with .o.stdout)
lib/n/time: basic time module, follows Go's time