I hadn't realized before that mscan tracks "block" labels and "type"
labels separately and prefers type labels over block labels.  So, in
fact, kalloc's should always be labeled (using block labels) and
suballocations from these blocks should also be labeled (using type
labels).

Previously, radix_node's constructor would zero all of the pointers.
Now we use zalloc.  This fixes physical sharing between the mmap that
first allocates a radix node and every other operation that does
anything in that node (I argue this is not just sweeping this problem
under the rug: mmap obviously does not commute with address space
creation, which could theoretically pre-populate the radix tree.
Since that would consume too many resources, we do it lazily.  The
resulting physical sharing is exactly the same, it just happens at a
different time.)

This was originally to make radix_node rcu_freed, but that
didn't happen.  9x4 makes each radix_node one page and thus
easier to allocate.

zalloc uses work queues.  Technically, we're okay as long as we don't
*use* the zallocator until wq is initialed, but that seems fragile.

percpu acts like a T* const, so a const percpu should (also) be like a
T* const, *not* like a const T*, which is what the code previously did
(remember, C types are inside-out!  except when they aren't).  This,
for example, makes it sane to pass a const percpu reference.

This also makes percpu non-copyable and non-assignable and makes stuff
private.

Previously, we always used the name of CPU 0's kmem for a slab (owing
to the same type of pointer decay problem fixed by the last commit).
This is why all mtrace labels are called things like "0kstack" instead
of having the right CPU number.

Previously, ksfree passed the whole CPU array for a slab to
kfree_pool, which expected a pointer to the specific kmem to free to.
Since the array decayed to a pointer, this compiled and worked, but
would always free to CPU 0's slab.

RCU-freeing the radix_nodes was punted for now, so we shouldn't need
this.

We use it for the AP boot code and stack and could free it after that,
but it's easier not to.

Simplifies the range locking code. Also we don't need that silly struct.

Simplifies things. radix_node is not RCU-freed and remains a power of
two. update_range always succeeds and doesn't need to return how far it
got.

Start at the appropriate index and stop early enough.

We want the level for use with index(). Probably should just drop
cur_end now that it's redundant. Also reorder all those arguments to be
saner.

Both have intentionally similar APIs, so this takes advantage of
design polymorphism to collapse a lot of previously conditional code.

So I can stop hunting for things like this.  I also planned to use
these in user space (cpputil.hh isn't user space friendly), though
didn't wind up doing that.

If no tests are named, run them all, like before.

:(