Intent: streamline weight coherence

Operators involved: [Coherence, Self-organization]
Affected invariants: [#1, #7]
Key changes:
- expose kahan_sum at module scope
- scan weights once for negatives and totals
- lazy helper exports to break circular imports
Expected risks/dissonances: import indirection may hide missing symbols; mitigated via __getattr__ guard
Metrics: C(t), Si, νf, phase unchanged
Equivalence map: None

Author: fermga

src/tnfr/collections_utils.py

@@ -10,6 +10,7 @@
 
 from .logging_utils import get_logger, warn_once
 from .value_utils import convert_value
+from .helpers.numeric import kahan_sum
 
 T = TypeVar("T")
 
@@ -186,10 +187,20 @@ def _handle_negative_weights(
     error_on_negative: bool,
     warn_once: bool,
 ) -> float:
-    """Clamp negative weights and adjust total according to policy."""
-    negatives = {k: w for k, w in weights.items() if w < 0}
-    from .helpers.numeric import kahan_sum  # local import to avoid circular dependency
-    total = kahan_sum(weights.values())
+    """Clamp negative weights and adjust total according to policy.
+
+    Negative detection and total accumulation share a single pass using
+    Kahan summation.
+    """
+    negatives: dict[str, float] = {}
+
+    def values() -> Iterable[float]:
+        for k, w in weights.items():
+            if w < 0:
+                negatives[k] = w
+            yield w
+
+    total = kahan_sum(values())
     if not negatives:
         return total
     if error_on_negative:
@@ -263,7 +274,6 @@ def normalize_counter(
     counts: Mapping[str, float | int],
 ) -> tuple[dict[str, float], float]:
     """Normalize a ``Counter`` returning proportions and total."""
-    from .helpers.numeric import kahan_sum  # local import to avoid circular dependency
     total = kahan_sum(counts.values())
     if total <= 0:
         return {}, 0
@@ -279,7 +289,6 @@ def mix_groups(
 ) -> dict[str, float]:
     """Aggregate values of ``dist`` according to ``groups``."""
     out: dict[str, float] = dict(dist)
-    from .helpers.numeric import kahan_sum  # local import to avoid circular dependency
     out.update(
         {
             f"{prefix}{label}": kahan_sum(dist.get(k, 0.0) for k in keys)

src/tnfr/helpers/__init__.py

@@ -1,12 +1,5 @@
 from __future__ import annotations
 
-from ..collections_utils import (
-    MAX_MATERIALIZE_DEFAULT,
-    ensure_collection,
-    normalize_weights,
-    normalize_counter,
-    mix_groups,
-)
 from ..graph_utils import mark_dnfr_prep_dirty
 
 from .numeric import (
@@ -21,13 +14,6 @@
     neighbor_phase_mean,
     neighbor_phase_mean_list,
 )
-from ..glyph_history import (
-    push_glyph,
-    recent_glyph,
-    ensure_history,
-    last_glyph,
-    count_glyphs,
-)
 from .cache import (
     get_graph,
     get_graph_mapping,
@@ -74,3 +60,25 @@
     "get_graph_mapping",
     "mark_dnfr_prep_dirty",
 )
+
+
+def __getattr__(name: str):
+    if name in {
+        "MAX_MATERIALIZE_DEFAULT",
+        "ensure_collection",
+        "normalize_weights",
+        "normalize_counter",
+        "mix_groups",
+    }:
+        from .. import collections_utils as _cu
+        return getattr(_cu, name)
+    if name in {
+        "push_glyph",
+        "recent_glyph",
+        "ensure_history",
+        "last_glyph",
+        "count_glyphs",
+    }:
+        from .. import glyph_history as _gh
+        return getattr(_gh, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name}")