[Internal] Improve Constraint Solving

[tnowacki]

We should collapse most constraints into into a single type when possible.

For example

fun ex<U, T: Show & Eq & U> 

We get an upper bounds array of

T => [%Show, %Eq, U]

We should instead collapse these into a single point
So

T => [-{Show, Eq}, U]

We can likely accomplish this by contra-promote joining the constraints
There are likely some issues though around tuples.
Such as

fun ex<T: (L, R) & (R, L)>

And even worse with

fun ex<U: R, T: (L, U) & (U, L)>

Since you likely want

T => [(L, U), (U, L), (L & R, L & R)]

But if we can accomplish this simplification it will

• Likely allow some simplifications for code when adding whenparams/conditional constraints
• Open up statics on tparams/generics

[pikatchu]

To open up statics on tparams/generics, we would have to have the guarantee that the simplification always works right? We would need a normal form I think.

What would that normal form look like, imagining that we had one?