fix: L1-only mode (backend=None) should not attempt Redis connection

When using @cache(backend=None) for L1-only caching, the decorator
was still attempting to connect to Redis on every operation.

Root cause: Sentinel problem - couldn't distinguish explicit backend=None
from unspecified backend.

Changes:
- Track explicit backend=None intent via _l1_only_mode flag
- Skip backend provider lookup in L1-only mode
- Fix invalidate_cache() to honor L1-only mode
- Add DEBUG log when L1-only mode ignores available Redis
- Clean up ttl or ttl copy-paste cruft

Closes #3

Author: 27Bslash6

src/cachekit/decorators/intent.py

@@ -1,7 +1,6 @@
-"""Intent-based intelligent cache decorator interface.
+"""Intent-based cache decorator interface.
 
-Provides the new @cache decorator with automatic optimization and
-intent-based variants (@cache.minimal, @cache.production, @cache.secure, @cache.dev, @cache.test).
+Provides the @cache decorator with intent-based variants (@cache.minimal, @cache.production, @cache.secure, @cache.dev, @cache.test).
 """
 
 from __future__ import annotations
@@ -16,18 +15,22 @@
 F = TypeVar("F", bound=Callable[..., Any])
 
 
-def _apply_cache_logic(func: Callable[..., Any], decorator_config: DecoratorConfig) -> Callable[..., Any]:
+def _apply_cache_logic(
+    func: Callable[..., Any], decorator_config: DecoratorConfig, _l1_only_mode: bool = False
+) -> Callable[..., Any]:
     """Apply resolved configuration using the wrapper factory.
 
     Args:
         func: Function to wrap
         decorator_config: DecoratorConfig instance with all settings
+        _l1_only_mode: If True, backend=None was explicitly passed (L1-only mode).
+                       This prevents the wrapper from trying to get a backend from the provider.
 
     Returns:
         Wrapped function
     """
     # Use the wrapper factory with DecoratorConfig
-    return create_cache_wrapper(func, config=decorator_config)
+    return create_cache_wrapper(func, config=decorator_config, _l1_only_mode=_l1_only_mode)
 
 
 def cache(
@@ -101,7 +104,11 @@ def cache(
 
     def decorator(f: F) -> F:
         # Resolve backend at decorator application time
-        # Only if backend is explicitly provided in manual_overrides
+        # Track if backend=None was explicitly passed (L1-only mode)
+        # This is a sentinel problem: we need to distinguish between:
+        # 1. User passed @cache(backend=None) explicitly -> L1-only mode
+        # 2. User didn't pass backend at all -> should try provider
+        _explicit_l1_only = "backend" in manual_overrides and manual_overrides.get("backend") is None
         backend = manual_overrides.pop("backend", None)
 
         # Backward compatibility: map flattened l1_enabled to nested l1.enabled
@@ -128,6 +135,9 @@ def decorator(f: F) -> F:
                 if backend is not None:
                     override_dict["backend"] = backend
                 resolved_config = replace(config, **override_dict)
+            # Check if config explicitly specifies backend=None (L1-only mode via config)
+            if not _explicit_l1_only and resolved_config.backend is None:
+                _explicit_l1_only = True
         # Intent-based presets (renamed per Task 6)
         elif _intent == "minimal":  # Renamed from "fast"
             resolved_config = DecoratorConfig.minimal(backend=backend, **manual_overrides)
@@ -150,8 +160,13 @@ def decorator(f: F) -> F:
             # No intent specified - use default DecoratorConfig with overrides
             resolved_config = DecoratorConfig(backend=backend, **manual_overrides)
 
-        # Delegate to wrapper factory
-        return _apply_cache_logic(f, resolved_config)  # type: ignore[return-value]
+        # Check if resolved config has backend=None (L1-only mode)
+        # This catches both explicit backend=None in manual_overrides AND backend=None via config presets
+        if not _explicit_l1_only and resolved_config.backend is None:
+            _explicit_l1_only = True
+
+        # Delegate to wrapper factory with L1-only mode flag
+        return _apply_cache_logic(f, resolved_config, _l1_only_mode=_explicit_l1_only)  # type: ignore[return-value]
 
     # Handle both @cache and @cache() syntax
     if func is None: