`silentNeverType` leak in contextual parameter types coming from anonymous non-aliased object type instantiations

### 🔎 Search Terms

silent never type return type inference alias propagating anonymous object

### 🕗 Version & Regression Information

- This is the behavior in every version I tried

### ⏯ Playground Link

https://www.typescriptlang.org/play/?ts=6.0.0-dev.20250827#code/JYOwLgpgTgZghgYwgAgAoB4AqA+ZBvAKGWTAAsIQAuZACgHsQYBXAGxmBZYgBNqaA3OCyYRqmAJTIAvLiYgA1iDoB3EJJnI5ilSADcBAL4ECoSLEQpUAYQYBnMFCYIwdKPiLIQEZcizYaEAAeEAhMLlB8UBC2dCz8orSCwgkS0rj8dMDc6umZ2dQYOPpGBNwhLHBRyIJuqAU2IPaOzq76peWVKMwgzsAMyDB0dACMfjSBfDlo6HjIZfCsYGLIBtjiYm0IdmDIUbaLw9IDQ8M0NFOExFFgTFAgnt5oZ3ux8RceV9GvEPrExAD0-2QAD0APweAziYpQ4xgACeAAcUAB1YBkAAiEAWLDAfiOs3mcEWywMbTKCAqVW6vX6gzoACYxhNaFMMKiMViiTi-GsNsYto0dntFvSjnT6Wd3p8bncHj5UM8vnEIFK-i9lb8-oCQeDiJDoWSOlS5DT7nSAMxMyZpaYAbUwAF1echMJttrtootzWKhubJTbLh6ZfcvPLFTFlarPhH4pqAUCwRCYfrjOTKV0TWA+mahgAWK0sm0YAmc4n4ZAIqB0BEklbO13893CnG5n10XP+jSB663EOPBU0dVvAMfD0xn6j7WJvXJmHtCmdAaZ7PHOgAVgL5yLMzmpZx1HtDrr6xdbsFY8Wa7ba87uG7EGDcqeg6Vw67o6HE7+yCnupWs90IA

### 💻 Code

```ts
interface P {
then: (onfulfilled: (value: T) => unknown) => unknown;
}

interface PConstructor {
new (executor: (resolve: (value: T) => void) => void): P;
}

declare var P: PConstructor;

declare function foo1(x: () => P<{ default: T }>): T;

const result1 = foo1(() => {
return new P((resolve) => {
resolve;
});
});

type WithDefault = { default: T };

declare function foo2(x: () => P>): T;

const result2 = foo2(() => {
return new P((resolve) => {
resolve;
});
});

declare function foo3(x: () => P<[T]>): T;

const result3 = foo3(() => {
return new P((resolve) => {
resolve;
});
});

declare function foo4(x: () => P<{ default: { prop: T } }>): T;

const result4 = foo4(() => {
return new P((resolve) => {
resolve;
});
});

declare function foo5(x: () => P<{ default: [T] }>): T;

const result5 = foo5(() => {
return new P((resolve) => {
resolve;
});
});
```

### 🙁 Actual behavior

Only `foo2` and `foo3` have errors and we can see that their inner `resolve`s reference `never`

### 🙂 Expected behavior

All of those should consistently error and `resolve` should be typed as `(value: unknown) => void`. Specifically, `foo1` and `foo2` are the almost the same signatures but `foo2` is using a type alias in its declaration which changes the inference behavior. This is strong indication of the bug here

### Additional information about the issue

_No response_

Start by reproducing the Playground example and comparing contextual parameter inference across foo1 through foo5, especially anonymous object instantiations versus the aliased WithDefault type. Trace the type inference path that produces the inner resolve type; done when all five cases consistently report errors and type resolve as accepting unknown.

Written by the indexing model from the issue text.