Create a separate receiver object for each signal/callable connect

[usiems]

This way we can't run out of slot IDs.
This fixes #362

This also enables us to associate the receiver with the instance object of the callable (if it is a method of a QObject-derived class) instead of the sender, so that it is associated with the correct thread, which is important for the AutoConnection used.
In a way this also fixes the problem in #363, because now the receiver object should always live in the same thread as the self object of the callable. The connection to a callable doesn't use the actual slot defined by a slot decorator, but the effect should be largely the same.

Note that this might change the behavior of signal/callable connections when threads are used, so users need to test if their uses still work for them.

[mrbean-bremen]

Looks good as far as I can see (though I may miss some possible implications)

[florianlink]

1. removeSignalHandler now removes all matches for a callable
   The old code breakd after removing the first matching target; the new loop removes every receiver whose isSameCallable(callable) returns true:

So connect(signal, f); connect(signal, f); disconnect(signal, f) now disconnects both, where previously it disconnected one. This actually matches Qt's native disconnect semantics (removes all matching connections), so it's arguably more correct — but it's a behavior change worth documenting in the PR description / changelog since the author already flagged thread-related behavior changes.

2. Only destroyed(QObject*) is watched now
   The old code tracked both destroyed() and destroyed(QObject*) via _destroyedSignal1Id/_destroyedSignal2Id. The new code only connects to destroyed(QObject*). This is fine for modern Qt (the arg variant is the canonical one), but it's a subtle narrowing — if anything on the QObject::staticMetaObject ever emits the no-arg form in some legacy/Qt-version scenario, the receiver wouldn't self-clean. Low risk, just noting.

[usiems]

1. removeSignalHandler now removes all matches for a callable
   The old code breakd after removing the first matching target; the new loop removes every receiver whose isSameCallable(callable) returns true:

So connect(signal, f); connect(signal, f); disconnect(signal, f) now disconnects both, where previously it disconnected one. This actually matches Qt's native disconnect semantics (removes all matching connections), so it's arguably more correct — but it's a behavior change worth documenting in the PR description / changelog since the author already flagged thread-related behavior changes.

Thanks for the hint! I could change it back if you would feel better about it, otherwise I will just document the change.

2. Only destroyed(QObject*) is watched now
   The old code tracked both destroyed() and destroyed(QObject*) via _destroyedSignal1Id/_destroyedSignal2Id. The new code only connects to destroyed(QObject*). This is fine for modern Qt (the arg variant is the canonical one), but it's a subtle narrowing — if anything on the QObject::staticMetaObject ever emits the no-arg form in some legacy/Qt-version scenario, the receiver wouldn't self-clean. Low risk, just noting.

I looked it up: The variant with the QObject* argument exists at least since Qt 5.6 (I would guess since Qt 5.0), and we don't support older Qt versions anymore since PythonQt 4.