I think an error should not be reported for calling type on any Python object.

The example here doesn't show any problematic code. It only shows mypy reporting incorrect information.

The fact that mypy reports incorrect information (in one version) is not a reason to report an error with that code (in a later version).

In the example of the linked issue, there is problematic code, but the problem is not in calling type. The problem is assuming that the result of the type call has foo.

A better solution would be that if type is called on an object with a protocol type, the result of the type call could be object.

Then it won't assume that it has a foo, and an error will be reported when accessing foo from the result of the type call.
error: "object" has no attribute "foo" [attr-defined]

or maybe the return type should be
type[P] | type[ModuleType]

Modules can implement protocols, so type(x) is not necessarily a type object if x has a protocol type.

What exactly does this sentence mean? The following raises no errors at runtime:

import typing
cls = type(typing)
assert isinstance(cls, type)  # ✅

Apologies if I am missing the obvious...

Using type(x) or annotating something as type[P] seems very reasonable. What if I want to do something very simple, like create a dict[str, type[P]] that holds all available implementations for a given Protocol?

type(module) is a type object, but it (probably) isn't a type object implementing the protocol that the module implements. For example, in Jukka's post above, a module with an f() function would implement the protocol, but type(module) would return types.ModuleType, which isn't a type[P].