space: skip asserts for KIP/UTCB ranges

For those, the effect of a flushing Unmap is not required to remove the pages,
nor affect the pagetable presence or write permission.
test: space: add no_{unmap,flush}_kip_utcb

These both test that the system call returns the same fpage with reset access
bits, and the flush test also checks that the KIP wasn't unmapped (by
comparing crc32 sums of the first 0xff bytes before and after) and that
writing to the KIP causes a segfault.
testbench: reorganize space_suite()'s cases

And merge "special" into "unmap".
add iff1, imply1 to <ukernel/invariant.h>

Clearly useful even if the whole mechanism is overly CPU-intensive. (perhaps
inv_push() could be a no-op unless DEBUG_ME_HARDER is at least 2?)
mapdb: add explicit special values to map_entry->parent.space

Invariants were updated to match the new parent.space semantics wrt IDs 0-1.

Now, mapdb_add_map() will only add parentless maps to sigma0, or when the
global sigma0_space == NULL. So after boot, orphaned map_entries are only
produced by nonrecursive immediate unmap (i.e. grant, map-over) of a map_entry
that had children and no parent.

Also, mapdb_unmap_fpage() gained a subtle mode for deletion of old UTCB
mappings by space_remove_thread(). discontiguate() was changed to never break
up a map_entry where parent.space == 1 to permit things such as large UTCB
entries and such while remaining completely idempotent in the face of
userspace unmaps.
test: thread: add test for UTCB page re-use

Seems to be working, if only in the simple "create N, join N" case.
mapdb: refuse maps into or from KIP and UTCB ranges

The implementation is inelegant but workable. It should instead be sensitive
to REF_SPACE(e->parent) == 1 in the source or target positions; right now it
instead does about 40 instructions of work to determine that neither source or
destination overlaps with kip_area or utcb_area in the respective space.
space: add mapdb calls to space_set_kip_area()

And require the address space not to contain threads that've been assigned
UTCB slots; this keeps any user thread from becoming confused (while NDEBUG
isn't set, anyway).

Also the REF_SPECIAL() macro in <ukernel/mapdb.h>.
mapdb: refactor special ranges in map_pages, add_map, unmap_fpage

Most importantly this removes the four-way fpage_overlap() test which took
about forty instructions to evaluate despite being false whenever programs
don't attempt to evoke undefined behaviour.

mapdb_map_pages() was refactored to just a simple/complex case split decided
efficiently with fpage_overlap(). Both sides entirely skip special mappings.

Likewise mapdb_unmap_fpage() was changed to support a special operating mode
that allows special mappings to be removed. This mode is never invoked by
userspace, and is always invoked (using the mapdb_erase_special() wrapper) by
the relevant space_*() functions.
test: ipc: add forbid_map_{from,into}_special

These are supposed to verify that pages mapped into the special ranges (UTCB,
KIP) cannot be unmapped by mapping a thing over them, or by granting them
away. Similarly, mapping them out should be a no-op.
testbench: add alloc_aligned(), its use in ipc_suite.c

This doesn't remove net lines of code, but it does do away with many lines of
very ugly code.
test: ipc: make forbid_map_.*_special fancier

This makes them looped, which is only proper, and further adds the is_grant
and is_large modes to forbid_map_from_special.
mapdb: refactor probe_group_range(), tighten asserts

Now it works in terms of fpage_overlap() which is much nicer than repeated
probe_group_addr(), though still a linear search by nature.
mapdb, space: small range predicate tweaks

ADDR_IN_FPAGE() was changed to use fpage_overlap() between the given fpage and
an invalid fpage which is nevertheless accepted by fpage_overlap(). This lets
GCC inline the MIN() clause away in the latter.

With that gain in mind, a BETWEEN() was replaced with an ADDR_IN_FPAGE() in
deref_child().

sys_spacecontrol() now tests overlap between kip_area and utcb_area with
fpage_overlap() for clarity, and cares about @utcb_area for correctness.
testbench: add ForkServ::get_utcb_area()

Used in the upcoming "don't kick the goddamn baby" UTCB area test.
test: ipc: add forbid_map_into_utcb_range

It tests maps into the UTCB area where UTCB pages haven't been mapped yet,
though only in the small-page case.

Also rename forbid_map_into_special to "_over_" for contrast.
ipc: add KIP and UTCB area overlap checks to apply_mapitem()
test: space: settle the poker and stats pager in during setup

This may not be sufficient but it does keep large_flush's base case
preconditions from blowing up, which seems to have been dependent on
scheduling vagaries when tests were added. Most likely this happened in
response to VM host load.