refactor: pure dataclass Fluid architecture with two-level caching

Architecture refactoring:
- Replace ThermoSystem (JVM reference) with pure dataclass Fluid + FluidProperties
- FluidStream is now a pure dataclass without JVM reference
- Introduce FluidService with dependency injection for flash operations
- Rename StreamMixer to SimplifiedStreamMixer
- Extract remove_liquid to separate method

Performance improvements:
- Add two-level caching: reference fluid cache and flash operation cache
- Add CacheService for centralized cache management

Bug fixes:
- Fix circular import issue in thermo.py
- Fix cache stats printout for pytest

Tests and documentation:
- Add cache behavior tests for fluid service
- Update snapshots for precision changes
- Add reference state warning to flash_ph docstrings
- Clarify standard density and cache key structure

Chore:
- Include anonymous volume in docker services to avoid venv issues

Author: kjbrak

.dockerignore

@@ -3,4 +3,5 @@ venv/
 docs/
 examples/
 .github/
-.pytest_cache/
+.pytest_cache/
+tests/.pytest_cache/

src/ecalc_neqsim_wrapper/__init__.py

@@ -1,3 +1,7 @@
+from ecalc_neqsim_wrapper.cache_service import CacheService, LRUCache
+
+# Import last to avoid circular import (fluid_service depends on thermo)
+from ecalc_neqsim_wrapper.fluid_service import NeqSimFluidService
 from ecalc_neqsim_wrapper.java_service import NeqsimService
 from ecalc_neqsim_wrapper.thermo import NeqsimFluid
 

src/ecalc_neqsim_wrapper/cache_service.py

@@ -0,0 +1,121 @@
+"""Centralized cache management for NeqSim-related caches.
+
+All caches registered here will be cleared when the JVM service shuts down,
+ensuring no dangling references to JVM objects.
+"""
+
+from __future__ import annotations
+
+import threading
+from collections import OrderedDict
+from typing import Generic, TypeVar
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+class LRUCache(Generic[K, V]):
+    """Thread-safe LRU cache with statistics tracking."""
+
+    def __init__(self, max_size: int = 10000):
+        self._cache: OrderedDict[K, V] = OrderedDict()
+        self._max_size = max_size
+        self._lock = threading.RLock()
+        self._stats: dict[str, int] = {"hits": 0, "misses": 0, "evictions": 0}
+
+    def get(self, key: K) -> V | None:
+        """Get value from cache, returns None if not found."""
+        with self._lock:
+            if key in self._cache:
+                self._cache.move_to_end(key)
+                self._stats["hits"] += 1
+                return self._cache[key]
+            self._stats["misses"] += 1
+            return None
+
+    def put(self, key: K, value: V) -> None:
+        """Add value to cache with LRU eviction."""
+        with self._lock:
+            if key in self._cache:
+                self._cache.move_to_end(key)
+            self._cache[key] = value
+
+            while len(self._cache) > self._max_size:
+                self._cache.popitem(last=False)
+                self._stats["evictions"] += 1
+
+    def clear(self) -> None:
+        """Clear all cached entries and reset statistics."""
+        with self._lock:
+            self._cache.clear()
+            self._stats = {"hits": 0, "misses": 0, "evictions": 0}
+
+    def get_stats(self) -> dict[str, int | float]:
+        """Get cache statistics."""
+        with self._lock:
+            total = self._stats["hits"] + self._stats["misses"]
+            hit_rate = (self._stats["hits"] / total * 100) if total > 0 else 0
+            return {
+                **self._stats,
+                "size": len(self._cache),
+                "max_size": self._max_size,
+                "hit_rate_percent": round(hit_rate, 1),
+            }
+
+    def __len__(self) -> int:
+        with self._lock:
+            return len(self._cache)
+
+
+class CacheService:
+    """Central registry for application caches.
+
+    Usage:
+        # Create a cache
+        my_cache = CacheService.create_cache("my_cache", max_size=1000)
+
+        # Use it
+        my_cache.put(key, value)
+        value = my_cache.get(key)
+
+        # All caches cleared on JVM shutdown automatically
+    """
+
+    _caches: dict[str, LRUCache] = {}
+    _lock: threading.RLock = threading.RLock()
+
+    @classmethod
+    def create_cache(cls, name: str, max_size: int = 10000) -> LRUCache:
+        """Create and register a named cache."""
+        with cls._lock:
+            if name in cls._caches:
+                return cls._caches[name]
+            cache: LRUCache = LRUCache(max_size)
+            cls._caches[name] = cache
+            return cache
+
+    @classmethod
+    def get_cache(cls, name: str) -> LRUCache | None:
+        """Get a cache by name."""
+        with cls._lock:
+            return cls._caches.get(name)
+
+    @classmethod
+    def clear_all(cls) -> None:
+        """Clear all registered caches. Called on JVM shutdown."""
+        with cls._lock:
+            for cache in cls._caches.values():
+                cache.clear()
+
+    @classmethod
+    def clear_cache(cls, name: str) -> None:
+        """Clear a specific cache by name."""
+        with cls._lock:
+            if name in cls._caches:
+                cls._caches[name].clear()
+
+    @classmethod
+    def get_all_stats(cls) -> dict[str, dict]:
+        """Get stats from all caches for monitoring."""
+        with cls._lock:
+            return {name: cache.get_stats() for name, cache in cls._caches.items()}