types: use slab allocator for type bounds

[apoelstra]

Our existing type inference engine assumes a "global" set of type bounds, which has two bad consequences: one is that if you are constructing multiple programs, there is no way to "firewall" their type bounds so that you cannot accidentally combine type variables from one program with type variables from another. You just need to be careful. The other consequence is that if you construct infinitely sized types, which are represented as a reference cycle, the existing inference engine will leak memory.

To fix this, we need to stop allocating type bounds using untethered Arcs and instead use a slab allocator, which allows all bounds to be dropped at once, regardless of their circularity. This should also improve memory locality and our speed, as well as reducing the total amount of locking and potential mutex contention if type inference is done in a multithreaded context.

This is a 2000-line diff but the vast majority of the changes are "API-only" stuff where I was moving types around and threading new parameters through dozens or hundreds of call sites. I did my best to break everything up into commits such that the big-diff commits don't do much of anything and the real changes happen in the small-diff ones to make review easier.

By itself, this PR does not fix the issue of reference cycles, because it includes an Arc<Context> inside the recursive Type type itself. Future PRs will:

• Take a single mutex lock during calls to the top-level bind and unify calls, so that these all happen atomically, including all recursive calls.
• Add another intermediate type under Type which eliminates the Arc<Context> and its potential for circular references. Along the way, make the Bound type private, which is not really used outside of the types module anyway.
• Do "checkpointing" during type inference that makes node construction atomic; this is #226 which is not fixed by this PR.
• (Maybe) move node allocation into the type inference context so that nodes can be slab-allocated as well, which will address #229 "for free" without us figuring out a non-recursive Drop impl for Arc<Node<N>>.

[uncomputable]

To summarize:

• Allocating all types of a given program in a single slab allows us to differentiate them from types of a different program. The slab can be dropped when the program is dropped / finalized.
• Doing the unification in LockedContext ensures we keep a write lock on the slab for the entire time of the operation. No other threads can write to the slab until we are finished. Is that correct?

[apoelstra]

Is that correct?

Correct on both counts.

[apoelstra]

Fixed both nits. Will leave the ShallowClone stuff to a later PR.