bootstrap: support for foreach
bootstrap:autointf: for extern struct, skip member-based inference
bootstrap:types: typ_hash(): ensure typ is not tentative

The 'hash' in a tentative typ is maintained as the typ gets linked to a
new typs. So 'hash' can be used in typ_equal(), etc. But it cannot be
used in a hash table *IF* elements of the table are re-linked while the
table exists. typset can be used in typ_isalist_foreach() with tentative
types when typs are not actively being linked. E.g. unify_generics()
typ_isalist_each(find_instance_of) is fine. So we cannot
assert(!typ_is_tentative(*a)) in general.
bootstrap:autointf: isalist literals need prototypes for all members

It is possible to type a call on a tentative isalist literal such as
	x#ctor, where x:{`default_ctor `copyable}.

For that to work, we need to add prototypes for each isa in the isalist
literal (a DEFINCOMPLETE).
bootstrap: nodes: store computed subs_count in parent
bootstrap:nodes: faster node_can_have_genargs()
t00/foreach
bootstrap:nodes: nparent() utility
1/10: bootstrap:nodes: node_get_member(): remove unneeded mod argument
2/10: bootstrap:printer: show '*' in front of tentative types; accept mod==NULL for printer_tree
3/10: PASS: support for FINALLY steps

When a step sets '*stop = true', all the later steps at the current
depth are skipped. But sometimes we need to perform some cleanup.
Finally steps are always called.
4/10: bootstrap:ssa: update current_statement when working on last in BLOCK
5/10: bootstrap:types: typ_hash_ready(): whether a hash is available

Not only do typ not have a well-defined hash early in the compilation
(before typ_hash_ready() is true), typ are not immutable, and their hash
can change (tentative types, tentative generics).

Therefore, while it's OK to store in a typset a typ with a non-final
hash, one must take care to not store a typ in a typset across hash
changes, or further lookup of that typ element will fail (it would have
been necessary to re-hash the element in the typset when the hash
changes, say).

This is a very difficult property to enforce, however (typ_hash_ready()
does not help with the update of hashes, only with their
initialization). It would be nice to get rid of it.
6/10: bootstrap:types: typ_isa: handle (ref `a) isa (ref `b) when `a isa `b
7/10: bootstrap:types: link_members

It is necessary to link 'src' members that introduce new types (DEFFUN
and DEFMETHOD) to their counterparts in 'dst'. This requirement will go
away when we don't introduce new types for each new method or function.
8/10: bootstrap:types: typ_is_concrete()

Examples of non-concrete types: uninstantiated generics or instances
within an instantiated generic which are instantiated over non-tentative
interfaces.

We will likely have to reconsider the latter case. (foo `t) is concrete
if `t is only ever used in code in a dyn (a dyn of any non-tentative
intf is concrete). We don't know how to check that property right now.
Instead we say that you have to use (foo @`t). This may not be
sufficient in general. This breaks `environment as written, although we
may be able to fix that independently.
9/10: bootstrap: topdeps-driven passes order

This is quite a large change, as the new pass ordering made evident a
number of issues, some that just weren't relevant with the old order,
some that just didn't show up and now do because of new examples.

- topdeps: keep track of needed typs for each toplevel node. Track
  separately final typs in a typset, and tentatives typs in a list (as
  they cannot be hashed). Typ that were tentatives are moved to the set
  once they're final.

- passes.c: step_push_state(): before processing a toplevel node, ensure
  all required typ definitions have been processed far enough. Circular
  dependencies are generally fine, but there are a few holes (see
  t00/fixme15.n for instance).

- passes.c: catchup(): change catchup() logic. Do not catchup any
  further than the node that triggered the instantiation. We use to rely
  on how far the module of the generic had been processed, but that's
  wrong. We can't go any further than the generic arguments of the
  instance have been processed. In general, 'passed' of the triggering
  node is a lower bound.

- catchup(): add the tentative bit for CATCHUP_TENTATIVE_NEW_INSTANCE
  earlier. Don't wait for the full catchup_instantiation(), set it after
  passfwd0: indeed, later passfwd may themselves trigger further
  instantiations, abd we need the tentative bit to be properly set.

- passbody2: move step_track_ident to a new pass. It's really tricky to
  track variable use-order while at the same time doing tree rewriting
  (passbody1 generates operator calls), so we move it to its own pass
  that does nothing else.

- passbody: step_add_dyn_topdep: each type depends on @{,!,#}`i for all
  the interfaces it implements. This is heavy handed, as in practice not
  all interfaces are always needed.o

- passfwd: move step_check_exhaustive_intf_impl() from passbody to
  passfwd. The check came too late in passbody: by that point, we may
  already have been looking for a missing member, resulting in a less
  helpful error, or worse, we may have assumed it existed through a
  simple isa check.

Mostly unrelated, but hard to isolate:

- cprinter: prefix dyn generated structs with _$Ndyn_ and _$Ndyntable_

- `prevent_dyn: fix for proper detection

- unify: fix unify_reference_with_refcompat: for @a,@b: differentiate a
  isa b from b isa a.
10/10: Accept test output changes
t00/automagicderef: correct FIXME comment
Use '..' for range instead of '...'

Swift is using .. for (opened) range and ... for closed range. While we're
not convince of the wisdom of introducing such an typo prone syntax, we
see no reason to use a different syntax for ranges. Many languages
already use '..'. As long as no one was using '...' it was fine to be
different; not anymore.