This has the advantage the transactions will also use it, preventing them
from blocking.

This reduces the number of huge allocs, which drops test time from 6 minutes to 57 seconds.

Inefficient scheme for allocations > 1/8192 of the pool size.

We can have a 0 byte in the *middle* of an encoding.

We can't allow NULL with the new variant (needed by talloc's set_destructor
for example), so document that and expose all three variants for different
uses.

cast_if_type() should not try to degrade the expression using 1?(test):0,
as that promotes bool to int, as well as degrading functions to function
pointers: it should be done by the callers.

In particular, this fixes sparse_bsearch.

This means we can't have more than 2^25 elements per page; that's
a maximum small page size of about 2^24 (with >8 objects per small page
we move to large pages), meaning a poolsize max of 4G.

We have a tighter limit at the moment anyway, but we should remove it
once we fix this.  In particular count all-zero and all-one words in
the used field (that's what we care about: full or empty) would give us
another factor of 64 (we only care about larger pool sizes on 64-bit
platforms).

We can also restore the larger number of pages and greater inter-page
spacing once we implement the alternative tiny allocator.

Turns out that now we use page numbers, this is more fundamental.

This version has limitations: pools must be at least 1MB, and allocations
are restricted to 1/1024 of the total pool size.

Particularly useful for building tests standalone.

To do this, we have to lose the ability for preargs and postargs to allow const and volatile argument signatures.

hashtable: make traverse callback typesafe.