Now this program works:
```py
from typing_extensions import ParamSpec
from typing import Generic, Callable

P = ParamSpec("P")

class Z(Generic[P]):
	def call(self, *args: P.args, **kwargs: P.kwargs) -> None:
		pass

n: Z[[int]]

reveal_type(n)  # N: Revealed type is "repro.Z[[builtins.int]]"

def f(n: Z[P]) -> Z[P]:
	...

reveal_type(f)  # N: Revealed type is "def [P] (n: repro.Z[P`-1]) -> repro.Z[P`-1]"
reveal_type(f(n))  # N: Revealed type is "repro.Z[[builtins.int]]"
```

This program:
```py
from typing_extensions import ParamSpec, Concatenate
from typing import Generic

P = ParamSpec("P")

class Z(Generic[P]): ...

n: Z[[int]]

reveal_type(n)

def f(n: Z[P]) -> Z[Concatenate[bool, Concatenate[str, P]]]: ...

reveal_type(f)
reveal_type(f(n))
```

outputs:
```
repro.py:10: note: Revealed type is "repro.Z[[builtins.int]]"
repro.py:14: note: Revealed type is "def [P] (n: repro.Z[P`-1]) -> repro.Z[Concatenate[builtins.bool, builtins.str, P`-1]]"
repro.py:15: note: Revealed type is "repro.Z[[builtins.bool, builtins.str, builtins.int]]"
```

Next up: checking inputs match prefixes and why does it only work when
cache exists?

It wasn't actually cache...

I ran into this while testing an interface with ParamSpec :(

This reverts commit c46feec.

This commit caused bugs for some reason....

Main things left:
 - Concatenate with mypy_extensions args
 - Flag for non-strict Concatenate

Co-authored-by: Marc Mueller <30130371+cdce8p@users.noreply.github.com>

Co-authored-by: Marc Mueller <30130371+cdce8p@users.noreply.github.com>

This is required to allow positional arguments to be replaced with named
arguments.

Co-authored-by: Marc Mueller <30130371+cdce8p@users.noreply.github.com>

Co-authored-by: Marc Mueller <30130371+cdce8p@users.noreply.github.com>

pros:
 - more readable IMO
 - more concise
 - standardization of output

cons:
 - can be easy to miss double backets
 - I feel like this is a small deviation from normal mypy
   representations... but I have nothing to back that up.

Overall, I think it's a good thing to try at least.