Functions taking non-const references to pointers `(T*&)` allow
rebinding the pointer inside the callee. This behavior does not map
cleanly to Python, which has no equivalent concept of pointer rebinding.

In cppyy, this can lead to confusing and unintended side effects due to
pointer deduplication and proxy identity semantics.

This change explicitly rejects such argument types and raises a
`TypeError` with a clear explanation and suggested alternatives.

Here is an example of previously confusing behavior:

```Python
import cppyy

cppyy.cppdef("""

struct MyClass {
   int val = 0;
};

MyClass *staticPtr() {
   static MyClass x;
   x.val = 1;
   return &x;
}

void changePtr(std::string ptr) {
}

void changePtr(MyClass *& ptr) {
   static MyClass y;
   y.val = 2;
   ptr = &y;
}

""")

p1 = cppyy.gbl.staticPtr()
p2 = cppyy.gbl.staticPtr()

cppyy.gbl.changePtr(p2)

print(p1.val)
print(p2.val)
```

Output:
```txt
2
2
```

Here, it was completely not obvious that changing `p2` is changing the
`p1` pointer.