Alternative version of TypeGeneralizing

[kripken]

In offline discussion we thought it would be useful to compare the current
TypeGeneralizing impl with one that does not use the new optimization framework,
to get an idea for overheads etc.

This PR reimplements that pass on top of #6105, #6106, #6107, specifically it uses the
extracted subtyping discovery logic from Unsubtyping, and on top of that it builds a
graph and does a flow on it to find the generalized types.

The existing test has a new run line. Results look right to me, though a few are
different as this pass does look into unreachable code (and does not run DCE
internally).

Marking as draft as this is just for comparison purposes.

[kripken]

Updated after the new batch of tests landed for TypeGeneralizing.

This matches the output on almost all of them, except for

• CallRef where I don't think we know what we want yet, so I didn't look into it.
• ArrayCopy cases where one reference is null, which is unreachable code anyhow.

The code seems reasonable to me but it could be simplified more. In particular there are some obvious similarities to GUFA, so some kind of framework could be extracted to support them both.

[kripken]

@tlively Just a reminder for both of us that if we plan to look into the new optimization framework again then we should discuss this PR. I think it shows shorter and faster code than the other version of TypeGeneralizing, which suggests the new framework could be improved before we go in depth to use it in more places.

[tlively]

Yes, agreed. Finishing this single optimization with and without the new framework, then comparing the code complexity and performance will be an important first step before using the new framework more broadly.