Generic constraints are "shallow", don't account for depth subtyping

Nessuno ha ancora preso questa issue.

### 🔎 Search Terms

`ts1360 ts2322 generic fields` , `generic bound subtyping`, `generic constraint subtyping`, `could be instantiated with a different subtype of constraint`, `depth subtyping generics`, `parametric polymorphism depth subtyping`

### 🕗 Version & Regression Information

- This is the behavior in every version I tried, and I reviewed the [documentation for generics](https://www.typescriptlang.org/docs/handbook/2/generics.html) as of 5.9.2

### ⏯ Playground Link

[Playground link](https://www.typescriptlang.org/play/?ts=5.9.2#code/GYVwdgxgLglg9mABAZwIbAKYB4AqiMAeUGYAJsilAE4xgDmAfABQBQAkGKgLYYBclNegBpEAelGIAqmCoYANqmKlEUOIhwA6FgEp+eAN7tZUEFSSceYiQCE4UABb4qVOFWQjUFQgAcM0DKRaAL4sLKCQsAiI4GiYuPhEJOSI+ogAbqhyIHwCtHSIQczsFjnI1Hki4ogAyrByctEy8ooBKmo4ANoARBlZGF0Aulq66t292YMpRhgmZoglVogA6vYAnogwFA6biJlycADuAQD8LCEsVQCiBNzechiIcMCIwKgwWbIsMejYqeM5XQgii6BUQAB8UulMtl+F1SHA6CDCqw2F1gJt7F0dChFJt0RgKIDgeDEHCEV0gA)

### 💻 Code

Errors, as intended:
```ts
function safe(
name: string, // Unrelated to T.
): T {
return name // 'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint 'string'. (2322) 👍
}
```

Does not error, unexpectedly:
```ts
function unsafe(
name: string,
): T["value"] {
return name // No error. Why is this allowed?
}

// Example uncaught error:
unsafe<{ value: "cat" } | { value: "dog" }>(
"fish"
) satisfies "cat" | "dog"
```

### 🙁 Actual behavior

When `T extends string`, TypeScript correctly identifies that an arbitrary other `string` cannot be safely assigned to `T`, because `T` could be instantiated with any subtype of string.

When `T extends { value: string }`, TypeScript incorrectly allows an arbitrary other `string` to be assigned to `T["value"]`, even though `T` could be instantiated with any subtype of `{ value: string }`, and the depth subtyping rule for objects implies that the type of `T["value"]` is also a subtype of `string`.

### 🙂 Expected behavior

- **Both examples should fail with the same error.** It should not be possible to return `name` in the function `unsafe`.

More generally, TypeScript should be consistent in applying subtyping rules to generic constraints `T extends U`. If `U` is a primitive (like `string` or `"A" | "B"`) and `T` is checked as if it could be instantiated with any subtype of `U`, then the same rule should apply when `U` is an object type.
- **If this is working as intended**, the [generics documentation](https://www.typescriptlang.org/docs/handbook/2/generics.html) should be updated to clarify that generic bounds are "shallow," and the correct approach is to use a second generic parameter.

Ideally this disclaimer could go under both the section on [Generic Constraints](https://www.typescriptlang.org/docs/handbook/2/generics.html#generic-constraints) (stipulating that only the top level parameter is treated as generic), as well as [Using Type Parameters in Generic Constraints](https://www.typescriptlang.org/docs/handbook/2/generics.html#using-type-parameters-in-generic-constraints) (to the effect of "note that this is the _only_ way to handle this pattern").

### Additional information about the issue

_No response_

Inizia dal TypeScript Playground collegato e confronta l'esempio generico di string con l'esempio di accesso indicizzato usando l'istanziazione dell'unione mostrata. Leggi le sezioni Generic Constraints e Using Type Parameters in Generic Constraints della documentazione sui generics. Il lavoro è completato se entrambi gli esempi ricevono lo stesso errore appropriato oppure se la documentazione spiega chiaramente il comportamento del vincolo superficiale e l'approccio con il secondo parametro.

Scritto dal modello di indicizzazione a partire dal testo della issue.