Remove unreachable async code path for stale entry processing

- Removed lines 475-483 that checked entry._processing with next_time=True
- This code path was unreachable in async because mark_entry_being_calculated/mark_entry_not_calculated are called immediately in sequence
- The window for entry._processing=True was too brief to be hit by concurrent calls
- Simplified async path now only has two cases: next_time=True (return stale + background update) or next_time=False (recalculate and wait)
- Updated test docstring to reflect what's actually being tested (concurrent calls with stale cache)
- All 30 tests still passing

Co-authored-by: Borda <6035284+Borda@users.noreply.github.com>

Author: Copilot

src/cachier/core.py

@@ -472,15 +472,6 @@ async def _call_async(*args, max_age: Optional[timedelta] = None, **kwds):
                     _print("And it is fresh!")
                     return entry.value
                 _print("But it is stale... :(")
-                if entry._processing:
-                    if _next_time:
-                        _print("Returning stale.")
-                        return entry.value  # return stale val
-                    _print("Already calc. Recalculating (async - no wait).")
-                    # For async, don't wait - just recalculate
-                    # This avoids blocking the event loop
-                    result = await _calc_entry_async(core, key, func, args, kwds, _print)
-                    return result
                 if _next_time:
                     _print("Async calc and return stale")
                     # Mark entry as being calculated then immediately unmark

tests/test_async_core.py

@@ -560,10 +560,10 @@ async def async_func(x):
     @pytest.mark.asyncio
     async def test_stale_entry_being_processed_with_next_time(self):
         """
-        Test stale entry being processed returns stale value with next_time=True.
+        Test concurrent calls with stale cache and next_time=True return stale values.
         
-        This tests the code path where entry._processing is True and next_time=True,
-        causing the function to return the stale cached value instead of waiting.
+        When cache is stale and next_time=True, concurrent calls should return
+        the stale value while background recalculation happens.
         """
         call_count = 0