bootstrap:lir: support assign 'except = ...' (without let)

This should become the preferred form, instead of
	let except = ...
bootstrap: support 'except' as a conditional return outside of any try..catch

This makes a lot of functions shorter. While it is a little bit of an
oddity, it will show up everywhere so won't create challenges for
readers.
bootstrap:lir: lift restriction on except on DEFINC expr

The current DEFINCOMPLETE resolution, which is unable to handle method
calls on incomplete types, prevented the use of this form on bare Error
global constants such as OK or INVAL:
	except = INVAL -- won't work
	except = Error.INVAL -- works

Indeed, the LIR transform created (roughly):
	LET
	 DEFNAME
	  IDENT(tmp):definc
	  IDENT(INVAL)
	BLOCK
	 IF
	  CALL
	   BIN
	    IDENT(tmp):definc
	    IDENT(Operator_test) -- BOOM!
	 BLOCK
	  THROW
	   IDENT(tmp) -- only now would it unify to Error
	 BLOCK
	  NOOP

For now, we choose to resolve this by constraining expr to Error when
'except' is found, leading to:
	  CALL
	   BIN
	    TYPECONSTRAINT
 	     IDENT(tmp)
	     DIRECTDEF -- to Error
	    IDENT(Operator_test)

This prevents reuse of try/catch/except/throw/... with non-Error types.
This is something we may want to allow in the future, at which point we
would hopefully have addressed the DEFINC limitation.
bootstrap: get rid of 'bw' prefix for bitwise operators

This was a misguided attempt at preventing ambiguities in expressions.
Our precedence, unary/binary operator spacing, and parenthesising (sic)
rules make the problem moot.

Also, we are going to use these operators for set operations on Mask,
and we want the lighter syntax.
bootstrap: do not use vector with a small size of 0 (for gdb support)
t00/fixme17: weird parsing bug of x._y as (CALL X . Y)

The '._' is lexed as a number, because of the tolerance of '_' in number
literals and the dot from floating point. TODO
bootstrap:unify: unify_non_generic(): fixes for (generic, non-generic) case
bootstrap: fixes for global LET detection and cprinting
bootstrap:passfwd: global constant propagation

In C, there are strict rules for what a global variable initialization
expression can contain. N is more flexible for global LET definitions:
it allows referring to other global constants (i.e. the initial value of
other global variables).

This change introduces a step that propagates the constant expression
from one global LET to another LET that uses it. In this form, cprinter
generates valid C. See t00/contant for examples.
bootstrap:cprinter: print_top: skip DEFINCOMPLETE nodes earlier

And in particular, do not look in their topdeps, which are not relevant
at that point.
bootstrap: DEFINCOMPLETE support for multiple unresolved idents

When initializing a slice such as {A B C} where A, B, C are from an enum
E, we first build a DEFINC _Ngensymxxx{"A" "B" "C"} before we can
resolve that these idents come from E. So far, DEFINC supported a single
unknown ident.
bootstrap: introduce `Has_bitwise_operators

Allows to have a common intf for `Integer and `Set. Should maybe be
called `has_bitwise_operators and not be exported, but ncc0 currently
barfs on that.
lib/n/builtins: introduce `Partially_ordered
lib/n/builtins: add `Integer.To_{i,u}64 to make writing generics easier

Our clever naming conventions for integer conversion operations (To_* or
Trim_*) are predictably getting in the way of writing generics. For now,
our best solution is to encourage conversion through the large types I64
and U64. A more elegant approach may be needed.
lib/n/builtins/mask: bit mask type over enums

A (Mask Enum) is implemented like a integer bitmap, as in common in C.
With some important differences.

- This is orthogonal to the enum itself; which still takes values
  from 1 (or 0 if `Trivial_ctor).
- A Mask is strongly typed and cannot contain invalid values (e.g. ~x is
  a valid bitmask, whereas in C, unless the enum size is equal to the
  bitwidth, ~x will contain extra bits set to 1).
- Standard set operations are defined, reducing the risk of user error.

This is similar to EnumSet in Java.