Better sizing for recursive generators

In general, generators should 'grow' linearly with size parameter. For
example, a tree generator given a size of 20 should have approximately
twice as many leaf nodes (internal nodes is another story) as the same
generator with a size of 10. This change brings us much closer
(exactly?) to that. Previously, when we recurred, we simply halved the
size. This did not lead to linear growth. Instead, we now first start by
treating the size as the maximum number of desired leaf nodes. We then
generate a height: 1 to 5. It's important to note that we start with a
height of 1, and not 0, since the whole point of this is to wrap the
inner generator in a tree. Once we have the maximum number of leaf
nodes, and the height (h), we can solve for the branching the branching
factor (k):

k = number-of-nodes ^ (1 / h)

Now that we've determined the shape of the tree, we can use the
branching factor (k) to resize the recursive generator. Since these
sizes are almost always small (under 10), we take care to treat scalar
generators differently, and still allow them to reach the maximum size.
This means that instead of having leaf nodes with small scalar values,
the values at the leaves can still grow up to the maximum size.

It's important to note that this produces trees that, on average, are
perfectly balanced. If you require something different, you'll need to
write something specific to your use-case.

This change also introduces a new public helper function: recursive-gen,
which is useful for eliminating the boiler-plate from writing recursive
generators. Instead of having to deal with the resizing yourself, you
simply provide recursive-gen with your 'container' generator, and your
scalar generator. For example:

(gen/recursive-gen gen/vector gen/boolean)

This will generate trees of booleans.