Split the inode space into per-cpu spaces of size IPB that start at
the begining of a block.  Block awareness is important to avoid
contention on blocks themselves when allocating or freeing an inode
and updating on-disk structures.  That is, I don't want to make bio
scalable.

This might be a mistake because we can't control the order of global
construction, but we already have several global constructors that
were simply not being called before.  As long as we keep all global
constructors simple, this should be okay.

This fixes the deadlock where a thread tries to allocate an inode,
and calls ilock, while another thread is simultaneously freeing
the same inode.

Previously we assumed in many places that all pages between a VMA's
vma_start and vma_end belonged to that VMA.  For radix, the radix tree
is now the source of truth about which pages a VMA maps.  This will
let us replace subranges of a VMA without having to split the VMA into
two ranges (which would violate the commutativity rule; e.g. for
disjoint unmaps within the same VMA).

These methods are to support changes in the VM system.  key() and
span() let you interrogate the current position of the iterator.
next_change() and the copy/move constructors make it easy to work with
spans of equal elements.

I think the semantics used to be that the iterator would always start
at the first non-null element, which I broke when I switched to the
iterative implementation.  This fixes that and introduces a method
that will be useful once iterators can point to null elements.

This puts the trivial part of the radix_iterator constructor used by
end() in the class definition, so the compiler can see the full
definition of end().  This should let it inline it and, hopefully,
constant-eliminate it so it doesn't get called repeatedly.

In standard collection types, begin and end are methods of the
collection.  The global begin and end are defined in <iterator> and
simply call these methods.

Previously, the radix iterator unconditionally found the next non-null
leaf node, even if it fell outside of the range the iterator was
derived from.  This was obviously an efficiency issue, but it also
introduced unnecessary sharing because of the reads outside of the
iterator's range.  Now it takes an explicit upper bound and will stop
resolving elements when it reaches that bound.  The end() iterator is
now naturally represented in terms of this bound, rather than in terms
of a special-case key.

For asharing vm, this eliminates all violations of the commutativity
rule.

Since I couldn't figure out how to nicely work this bound into the
existing recursive traversal implementation, I reworked it to be
iterative and, I think, made it much simpler in the process.  This
does make one notable semantic change: previously the radix iterator
cached the element it pointed to, so an update to that element would
not affect the value returned by the iterator.  It no longer caches
it, which makes it behave more like a regular collection iterator.