False positive "reportArgumentType" if ParamSpec is inferred as generic argument

Nobody has claimed this yet.

```python
from typing import Any, Callable, Final, Protocol, overload

class MyCallable[F](Protocol):
call: Final[F]

class ImplCall:
@overload
def call(self, a: str, b: str) -> str: ...
@overload
def call(self, a: int, b: int) -> int: ...
def call(self, a: Any, b: Any) -> Any:
assert False

def takes_call[**P, R](f: MyCallable[Callable[P, R]]) -> Callable[P, R]:
assert False

def main():
# Argument of type "ImplCall" cannot be assigned to parameter "f" of type "MyCallable[(**P@takes_call) -> R@takes_call]" in function "takes_call"
# "ImplCall" is incompatible with protocol "MyCallable[(**P@takes_call) -> R@takes_call]"
# Type parameter "F@MyCallable" is covariant, but "Overload[(a: str, b: str) -> str, (a: int, b: int) -> int]" is not a subtype of "(**P@takes_call) -> R@takes_call"
# No overloaded function matches type "(**P@takes_call) -> R@takes_call" (reportArgumentType)
res = takes_call(ImplCall())

# return type is correct
# Type of "res" is "Overload[(a: str, b: str) -> str, (a: int, b: int) -> int]"
reveal_type(res)
```
The return type is inferred correctly so I would expect this to produce no error.

```
pyright 1.1.403
```

Start with the inline Python reproducer using pyright 1.1.403, focusing on the ParamSpec inference in takes_call and the protocol compatibility diagnostic. Confirm the current reportArgumentType error and reveal_type result, then verify that the diagnostic is removed while the overload return type remains correctly inferred.

Written by the indexing model from the issue text.