Distribute 'keyof' union types

[ahejlsberg]

With this PR we transform keyof applied to a union type to an intersection of keyof applied to each union constituent. In other words, we rewrite types of the form keyof (A | B) to keyof A & keyof B.

Some examples:

type A = { a: string, c: string };
type B = { b: string, c: string };

type T1 = keyof (A | B);  // "c"
type T2<T> = keyof (T | B);  // (keyof T & "b") | (keyof T & "c")
type T3<U> = keyof (A | U);  // ("a" | keyof U) | ("c" & keyof U)
type T4<T, U> = keyof (T | U);  // keyof T & keyof U
type T5 = T2<A>;  // "c"
type T6 = T3<B>;  // "c"
type T7 = T4<A, B>;  // "c"

This PR is the mirror image of #22300 and finally brings symmetry to the type eqivalences:

keyof (A & B) <==> keyof A | keyof B
keyof (A | B) <==> keyof A & keyof B

Why it took so long to figure out I don't know!

Fixes #23618.

[weswigham]

So, I don't know if it's related to this PR, but this change caught my eye:

{ [(super(), "prop")](): void; }

isn't a valid type. Somewhere we're reusing the name's expression tree when building the computed property name type and shouldn't be. :(

[ahejlsberg]

This is actually a baseline change from #23592. I somehow messed up a merge and ended up with a lot of apparent changes in this PR.

Anyways, what's not valid about the type? It's a method with a computed property name that uses the comma operator.

[weswigham]

That's supposed to be type output - if someone wrote type Foo = { [(super(), "prop")](): void; }, we'd issue an error.

[ahejlsberg]

I somehow ended up with a bad merge on this branch so I'm abandoning this PR in favor of #23645.