## `cache.invalidate()` raises `KeyError` when the key is not in the cache

Calling `.invalidate()` on a `@cache`-decorated function raises a `KeyError` if the key being invalidated is not currently in the cache. This makes the method non-idempotent and fragile to use in practice.

For example, calling `.invalidate()` twice for the same argument crashes on the second call:

```python
from funcy.calc import cache

@cache(timeout=60)
def inc(x):
    return x + 1

inc(0)          # populates cache
inc.invalidate(0)  # works fine
inc.invalidate(0)  # raises KeyError!
```

This also happens when the cache entry has already expired due to a timeout, or when two concurrent threads both try to invalidate the same key and one of them wins the race — the other gets a `KeyError`.

Currently the error is:
```
KeyError: (0,)
```

**Expected behavior:** `invalidate()` should silently do nothing if the key is not present in the cache, making it safe to call multiple times or in concurrent contexts.

**Actual behavior:** `invalidate()` raises `KeyError` if the key is missing, forcing callers to wrap every invalidation in a `try/except KeyError: pass` block.

Work in `/workspace`. Submit your fix in the existing Python source files under `funcy`. Preserve the other public behavior. The environment is offline; dependencies are preinstalled. Grading runs the repository's test suite in a fresh environment, using your submitted source files.