Fixes the bug reported by @MitchellAcoustics in #854 (comment): a ResultDict (or any mutable result) returned by a cached function is stored in the cache by reference, so mutating the returned object — by a downstream function in the same run, or by the user afterwards — silently corrupts the cache entry. The next pipeline.run then returns the mutated object instead of the original result (e.g. ErrorSnapshots stripped to nan), making repeated runs non-idempotent.

The fix

The in-memory caches now store and return deep copies:

• SimpleCache, LRUCache(shared=False), and HybridCache(shared=False) deep-copy values on put (snapshots the entry before anything can mutate it) and on get (so a consumer of a cache hit cannot corrupt the entry for the next hit). Both sides are required: copy-on-get alone cannot fix this bug, because the object returned to the caller is the stored entry.
• Shared caches (shared=True, the default) were never affected — they already isolate values via the cloudpickle/manager-proxy round-trip. DiskCache's disk path also already isolates via pickling; its in-memory LRU layer inherits the fix.
• Opt out with copy=False (e.g. LRUCache(shared=False, copy=False)) for large values that are never mutated. Values that cannot be deep-copied fall back to the original object with a warning.
• Documented in the caching concept page.

Performance

Copies are made only for the non-shared in-memory caches, once per put and once per hit. deepcopy is cheaper than the cloudpickle round-trip the default shared path already pays, and by definition cheaper than the recomputation the cache avoids. CodSpeed includes a cached-pipeline benchmark (test_calling_pipeline_directly_with_cache) which will quantify it.

Verification

• The repro test from this PR (tests/map/test_cache_result_dict.py) now passes.
• New unit tests: put-then-mutate-original, get-then-mutate-returned, and copy=False aliasing opt-out for all three in-memory caches, plus DiskCache's LRU layer.
• Full suite: 1412 passed; pre-commit run --all-files clean.

Addresses the caching pain point of #902. The separate notebook-staleness issue (cache keys don't include the function body, so editing a function returns stale cached results) is intentionally not part of this PR.