Add CacheListener for observing cache events

[Grryum]

Motivation

Currently the only way to observe cache activity is polling cacheStats, which exposes just cumulative hit/miss counters. There is no way to react to individual cache events, so common operational needs are impossible to express:

• exporting hits/misses/load durations to a metrics backend (Prometheus, Micrometer, ZIO metrics) with proper tags,
• observing evictions and invalidations (requested in Ability to add callback/hook to expiry events #44, attempted in Added invalidationEvents method to publish cache invalidation events. #57),
• measuring lookup latency, including failed lookups.

Changes

This PR adds a CacheListener that is notified of cache events:

trait CacheListener[-Key, -Error, -Value] {
  def onHit(key: Key)(implicit unsafe: Unsafe): Unit
  def onMiss(key: Key)(implicit unsafe: Unsafe): Unit
  def onLoad(key: Key, exit: Exit[Error, Value], loadTime: Duration)(implicit unsafe: Unsafe): Unit
  def onEviction(key: Key, cause: CacheListener.EvictionCause)(implicit unsafe: Unsafe): Unit
}

• onLoad fires for every completed lookup (both get misses and refresh) with the resulting Exit and the time the lookup took.
• onEviction carries the cause: Capacity, Expired, or Invalidated.
• A ready-made CacheListener.metrics(cacheName) reports all events with ZIO metrics (zio_cache_hits, zio_cache_misses, zio_cache_load_successes, zio_cache_load_failures, zio_cache_load_duration, zio_cache_evictions), tagged with the cache name.
• A listener is attached via new overloads of Cache.make, makeWith, and makeWithKey; with makeWithKey the listener observes the keys produced by the keyBy function.

Design notes

• Listeners are synchronous side-effecting callbacks, not ZIO effects. Hits and evictions are tracked on the non-effectful hot path of the cache (getUnsafe, the eviction loop in trackAccess), where running effects would require either blocking the eviction loop on user code or giving up the zero-allocation hit path. This mirrors Caffeine's StatsCounter. An effectful adapter (e.g. forking a handler on a Runtime) can be layered on top later without breaking anything.
• All methods have no-op defaults, so listeners override only the events they care about, and future events can be added without breaking existing implementations.
• A listener that throws cannot corrupt the cache: exceptions are caught around every notification, so promises are always completed and the internal state stays consistent.
• Existing constructors are untouched (binary and source compatible); the only MiMa filter added is for the private CacheImplementation class (its constructor gained a parameter).
• invalidateAll does not emit per-key events since the underlying map is cleared wholesale; this is documented.

[kyri-petrou]

I think this can be simplified / optimized to:

val invalidated = map.keySet()
map.clear()
if (invalidated.isEmpty) Exit.unit
else ZIO.foreachDiscard(invalidated)(key => trackEviction(key, CacheListener.EvictionCause.Invalidated))

Note that we can also have a conditional if (isNoopListener) and simply do a map.clear() in that case to avoid the penalty of all the extra operations

[Grryum]

ConcurrentHashMap#keySet() returns a live view backed by the map rather than a snapshot, so after map.clear() the invalidated set would be empty and no eviction events would be emitted. I kept the remove-and-check approach for a real listener, since it also ensures we only report entries actually removed by this invocation. I did add the suggested no-op fast path, which uses the original map.clear() directly.