Intersection with a mapped type breaks bypassing private assignability.

Nobody has claimed this yet.

### 🔎 Search Terms

private assignability intersection mapped type

### 🕗 Version & Regression Information

Latest as of today.

### ⏯ Playground Link

https://www.typescriptlang.org/play/?#code/CYUwxgNghgTiAEkoGdnwBrwN4CgCQADjAJYBuUALglAFzwB2ArgLYBGIMA3Pq3chSXoBzbgF8cOCgE8CCAJrwAvNni0GLdjHij4AMhW94-QUO3dps+AC0l8AArEwAawA8WVXSZsO2gDTwAcigAgD49Az4BYmEzCVAkOHgIEAp4AA86dG546ETk1Kk6OWzwXIR8+AAvOituHDTbKVU0BX0s+ttK5utw9qA

### 💻 Code

Given
```ts
declare class X {
private a: number;
b: string;
}
```

You're allowed to do:
```ts
type Y = { a: number } & { b: string };
declare let y: Y;
let x: X = y as Y & X;
```

But fails with:
```ts
type Z = Pick<{ a: number }, 'a'> & { b: string };
declare let z: Z;
let x: X = z as Z & X;
```

### 🙁 Actual behavior

`X` bypasses private assignability, but the _identical_ type `Y` errors.

### 🙂 Expected behavior

Either neither type is allowed to bypass private assignability, or both types are, since they're identical.

### Additional information about the issue

_No response_

Start with the linked TypeScript Playground reproduction and compare assignability for the explicit intersection and the Pick-based intersection. Trace the compiler's private-member assignability handling and mapped-type intersection behavior, then verify that the two equivalent examples produce consistent results.

Written by the indexing model from the issue text.