… memoryview (#22097)

`isinstance(x, complex)` wasn't specialized, so every call looked up
`builtins.complex` by name and went through `PyObject_IsInstance`.
Because the tuple fast path from #19949 only applies when
every member is a primitive type, `isinstance(x, (float, complex))` was
worse still: it built a new tuple on every call, and `float` lost its
fast path too. This is an issue I have run into in my personal projects.

This adds `isinstance` primitives for `complex`, `type`, `range`,
`slice` and `memoryview` (`PyComplex_Check`, `PyType_Check`, etc.), plus
direct type object loads for `complex`, `slice` and `memoryview` so
things like `type(x) is complex` don't go through `builtins` either.
Tuples such as `(float, complex)` and `(bytes, bytearray, memoryview)`
now use the existing chained checks.

Also fixes a typo in the name of the `isinstance(obj, int)` primitive
(`builtints.isinstance`).

Benchmarks in ns, Python 3.12:

|  | master | this PR |
| `isinstance(x, complex)` | 43.0 | 5.9 |
| `isinstance(x, (float, complex))` | 106.0 | 7.1 |
| `isinstance(x, (bytes, bytearray, memoryview))` | 101.8 | 5.4 |
| `type(x) is complex` | 22.2 | 4.3 |

Fixes mypyc/mypyc#1227

This is just an idea for how to improve performance, for an issue that
was exposed to me because of the issues in PR #22097 .

`isinstance(x, (A, B))` is specialized when every class in the tuple is
a primitive type (#19949) or every class is a native class
(mypyc/mypyc#413). Anything else falls back to the generic path, which
builds a new tuple and calls `PyObject_IsInstance` on every call, so the
primitive types in the tuple lose their fast checks as well. That
covers:

- a primitive type mixed with a native class: `isinstance(x, (float,
MyNativeClass))`
- a primitive type mixed with any other class: `isinstance(x, (float,
Decimal))`
- nested tuples, even when every class is a primitive type:
`isinstance(x, (int, (float, str)))`

The chained checks added in #19949 could be generalized:
flatten nested tuples, use the fast checks for primitive types and
native classes, and check any other class with its own
`PyObject_IsInstance` call, so no tuple is built. In a quick
microbenchmark this takes `isinstance(x, (float, MyNativeClass))` from
about 50 ns to about 5 ns per call.

Relatedly, `isinstance(f(), ())` currently returns `False` without
calling `f()`.