refactor: move MemoryStore seeding to setup_collection for lazy initialization

- Store seed data as instance variable instead of seeding synchronously in __init__
- Move seeding logic into _setup_collection which is called once per collection
- Remove _seed_store_sync method entirely
- Update docstring to clarify seeding occurs lazily when collection is first accessed

This provides cleaner separation of concerns and leverages the existing
setup infrastructure, ensuring collections are only seeded when actually used.

Co-authored-by: William Easton <strawgate@users.noreply.github.com>

Author: github-actions[bot]

key-value/key-value-aio/src/key_value/aio/stores/memory/store.py

@@ -109,6 +109,7 @@ class MemoryStore(BaseDestroyStore, BaseDestroyCollectionStore, BaseEnumerateCol
     max_entries_per_collection: int
 
     _cache: dict[str, MemoryCollection]
+    _seed: Mapping[str, Mapping[str, Mapping[str, Any]]]
 
     def __init__(
         self,
@@ -124,20 +125,18 @@ def __init__(
             default_collection: The default collection to use if no collection is provided.
             seed: Optional seed data to pre-populate the store. Format: {collection: {key: {field: value, ...}}}.
                 Each value must be a mapping (dict) that will be stored as the entry's value.
+                Seeding occurs lazily when each collection is first accessed.
         """
 
         self.max_entries_per_collection = max_entries_per_collection
 
         self._cache = {}
+        self._seed = seed or {}
 
         self._stable_api = True
 
         super().__init__(default_collection=default_collection)
 
-        # Seed the store if seed data is provided
-        if seed:
-            self._seed_store_sync(seed)
-
     def _create_collection(self, collection: str) -> MemoryCollection:
         """Create a new collection.
 
@@ -151,26 +150,23 @@ def _create_collection(self, collection: str) -> MemoryCollection:
         self._cache[collection] = collection_cache
         return collection_cache
 
-    def _seed_store_sync(self, seed: Mapping[str, Mapping[str, Mapping[str, Any]]]) -> None:
-        """Seed the store with initial data synchronously.
+    @override
+    async def _setup_collection(self, *, collection: str) -> None:
+        """Set up a collection, creating it and seeding it if seed data is available.
 
         Args:
-            seed: Seed data in format {collection: {key: {field: value, ...}}}.
-                Each value must be a mapping (dict) that will be stored as the entry's value.
+            collection: The collection name.
         """
-        for collection, items in seed.items():
-            # Ensure collection exists
-            collection_cache = self._create_collection(collection) if collection not in self._cache else self._cache[collection]
+        # Create the collection
+        collection_cache = self._create_collection(collection)
 
-            # Add items using the same logic as put
+        # Seed the collection if seed data is available for it
+        if collection in self._seed:
+            items = self._seed[collection]
             for key, value in items.items():
                 managed_entry = ManagedEntry(value=value)
                 collection_cache.put(key=key, value=managed_entry)
 
-    @override
-    async def _setup_collection(self, *, collection: str) -> None:
-        self._create_collection(collection)
-
     @override
     async def _get_managed_entry(self, *, key: str, collection: str) -> ManagedEntry | None:
         collection_cache: MemoryCollection = self._cache[collection]