Use plain sets for watcher dep bookkeeping

Watcher._deps and Watcher._new_deps were WeakSets. WeakSet is
implemented in pure Python, so the two membership checks and the add
in Watcher.add_dep -- which run for every dep touched on every watcher
evaluation -- each cost a Python function call, as does iterating in
cleanup_deps. Profiling showed this bookkeeping at 32-40% of runtime
in watcher-heavy workloads. Plain sets do the same operations in C.

Strong references to deps are safe here:
- Dep._subs remains a WeakSet, so there are no reference cycles and
  watcher lifecycle is unchanged: deleting a watcher still
  unsubscribes it from its deps.
- A dep whose container has been garbage collected is inert (nothing
  can notify it anymore) and is released on the watcher's next
  re-evaluation (cleanup_deps), on deactivation, or when the watcher
  itself is collected. Until then it keeps only a small Dep object
  alive, not the container.

Benchmarks (local, macOS, vs master):
- deep_watch_mutate_leaf: 1.33-1.49x faster
- notify_watchers: 1.49-1.61x faster
- read_dict_getitem_tracked: 1.58x faster
- untracked reads and plain baselines: unchanged

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: berendkleinhaneveld

observ/watcher.py

@@ -13,7 +13,7 @@
 from functools import partial, wraps
 from itertools import count
 from typing import Any, Callable, Generic, Optional, TypeVar, Union
-from weakref import WeakSet, ref
+from weakref import ref
 
 from .dep import Dep
 from .proxy import Proxy, proxy
@@ -219,7 +219,13 @@ def __init__(
             # or a list of proxies
             if deep is None:
                 deep = True
-        self._deps, self._new_deps = WeakSet(), WeakSet()
+        # Plain sets: WeakSet operations are implemented in Python and
+        # dominate the cost of re-collecting deps on every evaluation.
+        # Strong references are safe here: deps don't reference watchers
+        # strongly (Dep._subs is a WeakSet), and a dep whose container
+        # was garbage collected is dropped on the next cleanup_deps()
+        # or when the watcher is deactivated or collected.
+        self._deps, self._new_deps = set(), set()
         self._tasks = set()
 
         self.sync = sync

tests/test_deps.py

@@ -1,4 +1,6 @@
-from observ import computed, reactive
+from unittest.mock import Mock
+
+from observ import computed, reactive, watch
 from observ.proxy import proxy_db
 
 
@@ -53,3 +55,32 @@ def prop():
 
     state.clear()
     assert len(proxy_db.attrs(state)["keydep"]) == 3
+
+
+def test_deps_released_after_reevaluation():
+    # Watchers hold strong references to their deps, so check that
+    # deps of containers that the watched expression no longer visits
+    # are released when the watcher re-evaluates
+    state = reactive({"foo": {"bar": 5}})
+    watcher = watch(lambda: state, Mock(), sync=True, deep=True)
+
+    # The deep watcher depends on the outer and the nested container
+    assert len(watcher._deps) == 2
+
+    del state["foo"]
+
+    # The sync watcher re-evaluated and dropped
+    # the dep of the nested container
+    assert len(watcher._deps) == 1
+
+
+def test_deps_released_on_deactivation():
+    state = reactive({"foo": 5})
+    watcher = watch(lambda: state["foo"], Mock(), sync=True)
+
+    assert len(watcher._deps) > 0
+
+    # Deactivating the watcher releases its deps
+    watcher()
+
+    assert len(watcher._deps) == 0