There's not much difference between the situation for `callable` and for, say, `list` though. Both are built-ins, and both continue to be valid when called: `callable(x)` and `list(x)` keep their meaning. PEP 585 added `list[itemtype]`, which was previously invalid; a new PEP could add `callable[[arg1, arg2, ...], ret]`, with a new meaning.
The form `callable[...]` is currently *always* invalid (just like `list[...]` used to be); so it could be given a new meaning regardless of context.
The main difficulty would seem to be that `callable(x)` needs to continue returning a bool. Given that *if* we were to do this, type checkers would have to special-case `callable` anyways (it's not a simple generic type like `list` -- `Callable` is also a special form), the special-casing could include "and if it's not subscripted, it's a boolean function". I have a feeling that this would be doable -- we have some other rather special forms, e.g. `type`, which can be used as `type(x)`, `type(name, bases, namespace)`, and `type[cls]`. I don't know about Pyright, but mypy certainly has plenty of references to "builtins.type" that make me think it special-cases the snot out of it, and whatever its definition in typeshed doesn't convey the desired semantics.
I agree that there's no need to replace everything defined in typing.py with a builtin form; but PEP 677 (Callable Type Syntax) was proposed because it was the next most common special form after various things that were given built-in names by PEP 585. A substitute for `Any` is very low on the list (in part because its use is often a symptom of poorly typed code rather than of a missing typing feature).