Raise on async finalizer in close_sync; drop Group cache; slot exceptions

[lesnik512]

Summary

Four changes — items #1 and #9 from plan.md, plus two adjacent cleanups discovered during verification.

#1 — close_sync raises on async finalizers

Previously CacheItem.close_sync emitted a RuntimeWarning and silently returned when it found a cached resource with an async finalizer. The cache was preserved, but users had no actionable signal — they'd have to know to call close_async() next. Most won't.

Now CacheItem.close_sync raises AsyncFinalizerInSyncCloseError (a new exception class). The existing CacheRegistry.close_sync aggregation loop already wraps per-item exceptions into FinalizerError, so users get one clean error containing the list of offending types and a clear actionable message:

FinalizerError: Errors during sync cleanup: [
  AsyncFinalizerInSyncCloseError('Cannot run async finalizer for Resource during sync close. Use `await container.close_async()` (or `async with container:`) instead.')
]

Cached resources are preserved on the raise path, so the recovery flow ("call close_async() to actually clean up") is unchanged — just made explicit instead of silent.

Picked "raise" over "unified close()" per the plan.md options. A unified close() would still have to refuse on async finalizers (you can't await from sync code), so it'd be sugar over a louder close_sync() — feature creep without solving the actual choice.

#9 — drop Group.providers cache

Group.get_providers() snapshotted into a class attribute on first call. Dynamic mutation of a Group after the first introspection silently went unseen. Audit confirmed: only one caller (Container.__init__), trivial cost (a cls.__dict__ iteration over 2-10 attributes), no tests depend on the freeze. Now it just returns a fresh list every call. Pure correctness.

Bonus — __slots__ on all exception classes

Marker classes (ModernDIError, ContainerError, RegistrationError, ResolutionError) get __slots__ = (). Subclasses with instance attrs get explicit tuples. Matches the project's existing lean-memory style (Container, registries, dataclasses with slots=True).

Bonus — CacheItem.cache uses UNSET sentinel

None was overloaded as both "not cached" and a potentially-valid cached value. Two consequences:

1. A creator returning None was treated as never-cached — re-created on every resolve, finalizer never ran.
2. if self.cache and ... skipped finalizers for any cached-but-falsy resource (empty dict, 0, False, empty string). Same anti-pattern PR Argument suggestions, context falsy/None fix, docs lead with with #184 fixed in ContextRegistry.

Migrated CacheItem.cache to use types.UNSET as the "not cached" sentinel. All four discriminating sites updated (_clear, close_async, close_sync, cached_count in cache_registry.py; the two cached-value short-circuit reads in factory.py:resolve). Three new regression tests cover falsy-sync, falsy-async, and the None-returning creator path.

Test plan

• just lint — clean (ruff + ty)
• just test — 125 passed (3 new), 100% coverage
• tests/providers/test_singleton.py::test_request_singleton updated to expect FinalizerError wrapping AsyncFinalizerInSyncCloseError and uses is UNSET for cleared-cache assertion
• Sibling test test_sync_finalizer_exception_does_not_abort_remaining_cleanup continues to pass (same aggregation path)
• Manual smoke checks: container with async-finalized resource → FinalizerError(AsyncFinalizerInSyncCloseError); container with None-returning creator caches once and finalizes; container with empty-dict creator finalizes correctly

🤖 Generated with Claude Code