Type inference fails for application of higher-order generic function

**Code or Screenshots**
I'm not sure how to describe it better than giving an example:

```python
import typing as tp

class Wrapper[T](tp.NamedTuple):
value: T

type IdFn[T] = tp.Callable[[T], T]

def foo[T](f: IdFn[Wrapper[T]]):
def _id_fn(x: T):
# Wrapper isn't important, we could even
# return x
return f(Wrapper(x)).value

return _id_fn

# Type is inferred correctly for foo
reveal_type(foo) # "(f: (Wrapper[T@foo]) -> Wrapper[T@foo]) -> ((x: T@foo) -> T@foo)"

def id_fn[T](x: T) -> T:
return x

id_fn_foo = foo(id_fn)
reveal_type(id_fn_foo) # Should be (x: T) -> T, is "(x: Unknown) -> T@foo"
```

**VS Code extension or command-line**
I am running through the pylance (version 2026.1.1) extension, python 3.12.12

Reproduce the supplied Python snippet in Pyright or through the Pylance extension, then inspect the type-inference path for the higher-order generic call from foo(id_fn). Done means id_fn_foo is inferred as (x: T) -> T rather than using Unknown for the parameter.

Written by the indexing model from the issue text.