This PR effects how we relate a source "Object" type to a target union type when:

1. The source is not relatable to a single type in the target union.
2. The target union has discriminant properties.
3. The source type would be sufficiently covered by all constituents of the union.

For example, today if we were to change IteratorResult to be a discriminated union, the following example would no longer compile:

type IteratorResult<T, TReturn = T> =
  | { done: false, value: T }
  | { done: true, value: TReturn };

class NumberIterator {
  next() {
    return { done: false, value: 1 }
  }
}

let x: Iterator<number> = new NumberIterator();
// error TS2322: Type 'NumberIterator' is not assignable to type 'IteratorResult<number>'.
//   Type '{ done: boolean, value: number }' is not assignable to type '{ done: true, value: number }'.
//     ...

With this change, we will perform the following steps after all other relationship checks fail:

If 'source' is an Object type and 'target' is a Union type with discriminant properties:

1. Generate a matrix of combinations of discriminant properties and types 'source' can satisfy.
   1. If the number of combinations is above a fixed limit (currently 25), we consider the comparison too complex and determine that 'source' is not related to the 'target'.
2. Filter 'target' to the subset of constituents whose discriminants exist in the matrix.
   1. If any combination of types in the matrix does not have a match in 'target', we determine 'source' is not related to 'target'.
3. For each matching constituent of 'target', we relate the remaining non-discriminant properties of 'source' to 'target'.
   1. If any remaining properties are not related, we determine 'source' is not related to 'target'
   2. Otherwise, 'source' is sufficiently covered by all constituents of 'target' and they are related.

This means that now, for the example above, we perform the following steps:

type S = { done: boolean, value: number }
type T = { done: false, value: number } // T0
       | { done: true, value: number }  // T1

1. Generate the a matrix of combinations:
   1. Determine the discriminants d of S with respect to T: ["done"]
   2. Determine the discriminant types dt of d: [[true, false]]
   3. Generate the matrix of combinations c: [[true], [false]]
2. Filter T to the matching discriminants cm of c: [T0, T1]
   1. Determine that cm has at least one match for each combination in c.
3. Relate the remaining non-discriminants (["value"]) of S and cm.
   1. Determine that S["value"] is related to both T0["value"] and T1["value"], therefore S is related to T.

Further examples can be found in assignmentCompatWithDiscriminatedUnion.ts

Related: #2983
Fixes: #14865
Fixes: #30871
Fixes: #30170
Fixes: #12052
Fixes: #18421
Fixes: #15907
Fixes: #20889