fixup! gh-119333: Back up exception before calling PyContext_WatchCal…

…lback

I changed my mind about where to back up and restore the exception.
Instead of backing up and restoring once outside the loop over the
registered callbacks, the exception is backed up and restored each
time a callback is called.

This avoids concerns about what happens if a callback raises an
exception but returns non-negative.

This is also expected to be more efficient, not less, because the
common case is no watchers at all, in which case there is no
backup/restore overhead.  The second most common case is one watcher,
which is no less efficient than before.  The only time this is more
expensive is when there are two or more watchers, in which case the
overhead of the watcher callbacks probably dwarfs the overhead of the
extra backups anyways.

Python/context.c

@@ -119,23 +119,23 @@ static void notify_context_watchers(PyContextEvent event, PyContext *ctx, PyThre
     assert(interp->_initialized);
     uint8_t bits = interp->active_context_watchers;
     int i = 0;
-    PyObject *exc = _PyErr_GetRaisedException(ts);
     while (bits) {
         assert(i < CONTEXT_MAX_WATCHERS);
         if (bits & 1) {
             PyContext_WatchCallback cb = interp->context_watchers[i];
             assert(cb != NULL);
+            PyObject *exc = _PyErr_GetRaisedException(ts);
             cb(event, ctx);
             if (_PyErr_Occurred(ts) != NULL) {
                 PyErr_FormatUnraisable(
                     "Exception ignored in %s watcher callback for %R",
                     context_event_name(event), ctx);
             }
+            _PyErr_SetRaisedException(ts, exc);
         }
         i++;
         bits >>= 1;
     }
-    _PyErr_SetRaisedException(ts, exc);
 }