This is the last usage of TypedSlot (we should be clear now to remove
that step from the end of type inference now).

Compared to the prior scheme, this now inserts PiNodes at every PhiNode
corresponding to a given slot, rather than at each load. In principle,
that should mean that the types we compute across PhiNodes are more
precise than before.

I believe that means that all slot uses should be at least as precise
as before, but I haven't completely convinced myself yet.

Since this is now unused by `slot2ssa` downstream, we can happily remove
it from the rest of the compiler.

There's one more piece of logic that I still need to move downstream: we
should use the `bb_vartables` for undefined-ness as well. That will
allow us to finally remove the (now incorrectly named) `annotate_slot_load!`

Now that we have the `bb_vartables` from Inference, we can get a
converged (and frequently more precise) result for our inserted PhiNodes
directly, instead of trying to compute the fix point in the optimizer.

This change also improves the way that we are inserting PiNodes to
ensure that they are present in every block that requires them for
precision, not just where we are already inserting PhiNodes. This is
necessary due to the presence of `Conditional`, which means we may
have a refined type in a block even when dominated by a definition
whose type was precise outside of the Conditional.

Updates slot2ssa to use the `bb_vartables` for `undef` information.
As a bonus, evicts the final usage of `tmerge` in slot2ssa.

This also fixes a few crashes from the prior commit, esp. where I was
emitting PiNode(UndefToken(), Union{}) or where the PhiC nodes were
not being ordered correctly.

This allows downstream consumers, like the optimizer, to be sure that
they are only visiting blocks that Inference also visited.

Also update tests and remove some unnused variables in `slot2ssa`.

Now that type inference modifies branches to reflect static control flow
information, we can't search for the branch that we want to optimize away.

This means that inference modifies types and not IR statements
themselves. In order to make this happen, we pass have to pass
per-statement reachability information to the optimizer.

Also fixes up assorted review feedback.

We were doing this before, but the previous commit had changed it. The
problem is that the optimizer cannot rely on the `unreachable` vector
for its external entrypoint.

This restores the existing logic so that type inference will give you a
result that you can pipe into the optimizer and have it work, although
suboptimally since we won't be able to prune any unreachable branches.

I think it'd be a more maintainable data flow to have these results
collected manually and explicitly passed to the conversion routine for
the optimizer, but for now this follows the established pattern and
allows us to create a complete OptimizationState from an InferenceState.