bootstrap:inference: also auto de lhs of bin_rhs_unsigned
lib/n/builtins: native types are `Hashable32
lib/n/builtins/hashmap: Hashmap.Try_store
bootstrap:types: typ_name: make more robust on being-built typs
bootstrap:types: on-demand overlays 1/2: needs_map: check future logic against current impl
bootstrap:types: do not duplicate a functor quickisa table in its instances quickisa

Instead, just use the quickisa of the functor.
bootstrap:types: needs_map: improve logic
wip_less_users
do not do ungenarg past passbody0??
bootstrap:inference: wildcard: fix: always unify self_wildcard
bootstrap:printer: debug global ppptr: if set, pptree() prints node addresses

This is very useful when trying to break when a node is being processed.
Say you're trying to understand why a node is typed a certain way.

	$ run
	Ctrl-c early
	$ set ppptr = 1
	$ continue

Check the output in t00/file.n.o.tree (or call pptree() directly). Take
the address of the node, e.g.:

	0x00000001	LET :n.builtins.Void
	0x000000f0	 DEFNAME(_Ngensym1) :*(n.builtins.`Any_ref n.builtins.I32)

	$ watch -l ((struct node *) 0x000000f0)->typ
	$ run

gdb will break whenever 'typ' is updated.
bootstrap:types: typ.trigger_mod field: keep track for generics

Necessary for on-demand overlays, as we'll need to create instances with
the same trigger_mod as the base overlaid type.
bootstrap:types: on-demand overlays 4/4: translate: find existing overlay or create one

Previously, we would create overlays for all possible dependencies of a
generic: all children, all isas, all direct or indirect users of its
ungenarg; and all that recursively. That was of course crazy and
explosive. Especially because so many tentative generic instances are
very transient and that see barely any use before being linked away.

In other words, we were doing a lot of work, "just in case" it was
needed, even though the great majority of the time, it isn't.
Compilation times had recently ballooned out of control, as we added
more and more obscure corner cases to the "just in case" list.

The proper approach requires subtlety, but isn't as hard as we may have
feared. On 'olay(t, u)', we determine if 'u' needs to have an overlay
with respect to 't' (e.g. 'u' shares ungenargs with the functor of 't'),
and we create the required overlay on the fly.

The compilation is much faster, close to reasonable, pointing to a
bottleneck in typ_isa.