Type '`x.y.${Name}`' does not satisfy the constraint '`${string}.${Name}`'.(2344)

### 🔎 Search Terms

Template Literal Types, assignability, generics

### 🕗 Version & Regression Information

- Between versions 4.3.5 and 4.2.3 more cases like this started being supported ( `x.${Name}` became assignable to `${string}.${Name}` for example), however the `x.y.${Name}` case has not bees assignable in any version since template support was added up to and including current nightly ( 5.9.0-dev.20250702 )

### ⏯ Playground Link

https://www.typescriptlang.org/play/?ts=5.9.0-dev.20250702#code/PQKhCgAIUhhB7AtgBwJYBsCmkAurHYCGAzsZgE464AWhVAgpKsZCcagOYB2hARlrniQAFJgAeOTFwAmxAJSQAQgDooMACpCArmQA0kdinQBPSNMwAzVFyK5jyTAC41kAAY572APoBjaph8Aa0gAXkhyTABHLVQI+lJOHn5MTQAedX0AUTEHH0lpAD4Ablc1YHBxZHhKOwdwqJi4hO4+LDSvRnFJGRZFfUUC0NxyLUwi8HAPOoB3asDiAGVrHxTPBZ9yVGQcABYvAGZUgDlCAkguqVkDHE2uDkGwiOjYzHj2FuS0qEgf1zFlAAkAG8TgQAL6uXTfX7A4g3awcMGAkGnTAQ8DFCZTbAWQgYYjHVHnCSXFhw273IZPRqvZpJNrwVLQtz-YzI0FoyHM1yw+F3JHAjnozGTTyQLjwLgAcSkFFQPgA6nMWI8Gi83olWilGdzWcoAF5cn4woHkhFIw0YopAA

### 💻 Code

```ts
/**
* Compile time assert that A is assignable to (extends) B.
* To use, simply define a type:
* `type _check = requireAssignableTo;`
*/
export type requireAssignableTo<_A extends B, B> = true;

type worksSinceTypeScript4_3 = requireAssignableTo<
`x.${Name}`,
`${string}.${Name}`
>;

type fails = requireAssignableTo<
// Type '`x.y.${Name}`' does not satisfy the constraint '`${string}.${Name}`'.(2344)
`x.y.${Name}`,
`${string}.${Name}`
>;

type nonGenericWorks = requireAssignableTo<
`x.y.z`,
`${string}.z`
>;
```

### 🙁 Actual behavior

A compile error:

> Type '`x.y.${Name}`' does not satisfy the constraint '`${string}.${Name}`'.(2344)

### 🙂 Expected behavior

No compile error. The `.${Name}` portion of the type matches exactly, so this can be reduced to checking if `"x.y"` is assignable to `string` should be allowed.

### Additional information about the issue

I understand that in general not all cases like that are practical to support: perfect assignability checking of template strings is likely infeasible but I decided to report this case as I think this one suggest an algorithm that would be practical to implement and efficient: running a greedy algorithm to remove common constant substrings from the beginning and end of the string, including generic values, might be a viable approach, and would improve handling of this case.

Reproduce the reported generic template-literal assignability case in the linked TypeScript Playground, comparing it with the working `x.${Name}` and non-generic examples. Investigate the compiler's template-literal assignability checking and verify that the `x.y.${Name}` assertion compiles without regressing the existing cases.

Written by the indexing model from the issue text.