lib/n/reflect: Dynisa: O(1) dynamic isa
lib/n/builtins: Range, Index_iterator, ... methods should be inline

And they appear to inline fairly well with GCC -O3.
lib/n/reflect: Dynisa: minimize empty space in hashtable

On a fairly representative isalist, we can perform 1,000,000 successful
lookups in roughly 25ms (with -03). C++ dynamic_cast does something
somewhat similar in 100ms (with -O3; note how difficult it's getting to
write benchmark code that does the same thing many times, without having
GCC optimize everything away...).

Of course in C++, the linear lookup through the hierarchy means that the
cost of dynamic_cast really depends on the inheritance depth and the
exact lookup. If x has type 'struct long_name_b4' C++ can do the work in
40ms.

	let a = init_type "`Any"
	foreach _ in 0 .. 100_000_000
		let _ = di.find_entry a false

-- In C++

	#include <assert.h>
	#include <stdlib.h>
	#include <stdint.h>

	struct long_name_b0 {
	  virtual void foo(void) = 0;
	};

	#define b(p, n) \
	struct long_name_b##n : long_name_b##p { \
	  virtual void foo(void) {} \
	};

	b(0, 1)
	b(1, 2)
	b(2, 3)
	b(3, 4)
	b(4, 5)
	b(5, 6)
	b(6, 7)
	b(7, 8)
	b(8, 9)

	int main(int argc, char **argv) {
	  int zero = atoi(argv[1]);
	  int n = atoi(argv[2]);
	  int r = 0;

	  struct long_name_b9 x;
	  struct long_name_b0 *y = &x;

	  for (int i = 0; i < n; ++i) {
	    struct long_name_b0 *y1 = (struct long_name_b0 *)((uintptr_t)y + zero * i);
	    if (dynamic_cast<long_name_b1*>(y1) != NULL) {
	      r += 1;
	    }
	  }

	  return r;
	}
bootstrap: support for static 'isa'
bootstrap: support for generic implementation selection via isa
bootstrap:hash: implement in C and N same hash function

Taken from Go. Go also uses AES when AES instructions are available. We
will likely do the same down the road.

We will use hash32_n() for n.reflect though.
bootstrap: support for dynamic 'isa' operator
bootstrap:inference: bin ops: add missing `Ordered and `Has_equality isa checks
bootstrap:cprinter: replace generated *_mkdyn() with NLANG_MKDYN()

We avoid a function call, building the dyn object directly from the
dyntable with the NLANG_MKDYN() macro. We also need to use the dyntable
in other places, so we needed to have it exported.
bootstrap: do not put wildcard genargs in first position

We are soon going to allow omitting generic arguments, in effect making
them positional optional generic arguments. In most cases, users are
less likely to want to set wildcard genargs explicitly than they are to
set other generic arguments explicitly. Therefore, wildcard genargs go
last.
bootstrap: support for wildcard functions
bootstrap: support for omitting subsequent generic args in explicit instantiations

The spec will allow naming explicit generic arguments, so that the
declaration order of gen args not be too significant. But there is no
support for that yet.
bootstrap: support nullable dyn; let Say/Pr accept them and show "(null)"
lib/n: Check with === first in Operator_{eq,ne,le,ge,lt,gt} implementations
bootstrap: support for Dyncast