store: internal locking, remove Arc<Mutex<Store>> wrapper

Store now has internal Mutex for capnp appends and AtomicU64 for
size tracking. All methods take &self. The external Arc<Mutex<Store>>
is replaced with Arc<Store>.

- Store::append_lock protects file appends
- local.rs functions take &Store (not &mut Store)
- access_local() returns Arc<Store>
- All .lock().await calls removed from callers

Co-Authored-By: Proof of Concept <poc@bcachefs.org>

src/hippocampus/local.rs

@@ -16,7 +16,7 @@ pub fn memory_render(store: &Store, _provenance: &str, key: &str, raw: Option<bo
     }
 }
 
-pub fn memory_write(store: &mut Store, provenance: &str, key: &str, content: &str) -> Result<String> {
+pub fn memory_write(store: &Store, provenance: &str, key: &str, content: &str) -> Result<String> {
     let result = store.upsert_provenance(key, content, provenance)
         .map_err(|e| anyhow::anyhow!("{}", e))?;
     store.save().map_err(|e| anyhow::anyhow!("{}", e))?;
@@ -91,7 +91,7 @@ pub fn memory_links(store: &Store, _provenance: &str, key: &str) -> Result<Vec<L
     Ok(links)
 }
 
-pub fn memory_link_set(store: &mut Store, _provenance: &str, source: &str, target: &str, strength: f32) -> Result<String> {
+pub fn memory_link_set(store: &Store, _provenance: &str, source: &str, target: &str, strength: f32) -> Result<String> {
     let s = store.resolve_key(source).map_err(|e| anyhow::anyhow!("{}", e))?;
     let t = store.resolve_key(target).map_err(|e| anyhow::anyhow!("{}", e))?;
     let old = store.set_link_strength(&s, &t, strength).map_err(|e| anyhow::anyhow!("{}", e))?;
@@ -99,7 +99,7 @@ pub fn memory_link_set(store: &mut Store, _provenance: &str, source: &str, targe
     Ok(format!("{} ↔ {} strength {:.2} → {:.2}", s, t, old, strength))
 }
 
-pub fn memory_link_add(store: &mut Store, provenance: &str, source: &str, target: &str) -> Result<String> {
+pub fn memory_link_add(store: &Store, provenance: &str, source: &str, target: &str) -> Result<String> {
     let s = store.resolve_key(source).map_err(|e| anyhow::anyhow!("{}", e))?;
     let t = store.resolve_key(target).map_err(|e| anyhow::anyhow!("{}", e))?;
     let strength = store.add_link(&s, &t, provenance).map_err(|e| anyhow::anyhow!("{}", e))?;
@@ -107,7 +107,7 @@ pub fn memory_link_add(store: &mut Store, provenance: &str, source: &str, target
     Ok(format!("linked {} → {} (strength={:.2})", s, t, strength))
 }
 
-pub fn memory_delete(store: &mut Store, _provenance: &str, key: &str) -> Result<String> {
+pub fn memory_delete(store: &Store, _provenance: &str, key: &str) -> Result<String> {
     let resolved = store.resolve_key(key).map_err(|e| anyhow::anyhow!("{}", e))?;
     store.delete_node(&resolved).map_err(|e| anyhow::anyhow!("{}", e))?;
     store.save().map_err(|e| anyhow::anyhow!("{}", e))?;
@@ -164,21 +164,21 @@ pub fn memory_history(store: &Store, _provenance: &str, key: &str, full: Option<
     Ok(out)
 }
 
-pub fn memory_weight_set(store: &mut Store, _provenance: &str, key: &str, weight: f32) -> Result<String> {
+pub fn memory_weight_set(store: &Store, _provenance: &str, key: &str, weight: f32) -> Result<String> {
     let resolved = store.resolve_key(key).map_err(|e| anyhow::anyhow!("{}", e))?;
     let (old, new) = store.set_weight(&resolved, weight).map_err(|e| anyhow::anyhow!("{}", e))?;
     store.save().map_err(|e| anyhow::anyhow!("{}", e))?;
     Ok(format!("weight {} {:.2} → {:.2}", resolved, old, new))
 }
 
-pub fn memory_rename(store: &mut Store, _provenance: &str, old_key: &str, new_key: &str) -> Result<String> {
+pub fn memory_rename(store: &Store, _provenance: &str, old_key: &str, new_key: &str) -> Result<String> {
     let resolved = store.resolve_key(old_key).map_err(|e| anyhow::anyhow!("{}", e))?;
     store.rename_node(&resolved, new_key).map_err(|e| anyhow::anyhow!("{}", e))?;
     store.save().map_err(|e| anyhow::anyhow!("{}", e))?;
     Ok(format!("Renamed '{}' → '{}'", resolved, new_key))
 }
 
-pub fn memory_supersede(store: &mut Store, provenance: &str, old_key: &str, new_key: &str, reason: Option<&str>) -> Result<String> {
+pub fn memory_supersede(store: &Store, provenance: &str, old_key: &str, new_key: &str, reason: Option<&str>) -> Result<String> {
     let reason = reason.unwrap_or("superseded");
     let content = store.get_node(old_key)
         .map_err(|e| anyhow::anyhow!("{}", e))?
@@ -293,7 +293,7 @@ fn level_to_node_type(level: i64) -> crate::store::NodeType {
     }
 }
 
-pub fn journal_new(store: &mut Store, provenance: &str, name: &str, title: &str, body: &str, level: Option<i64>) -> Result<String> {
+pub fn journal_new(store: &Store, provenance: &str, name: &str, title: &str, body: &str, level: Option<i64>) -> Result<String> {
     let level = level.unwrap_or(0);
     let ts = chrono::Local::now().format("%Y-%m-%dT%H:%M");
     let content = format!("## {} — {}\n\n{}", ts, title, body);
@@ -326,7 +326,7 @@ pub fn journal_new(store: &mut Store, provenance: &str, name: &str, title: &str,
     Ok(format!("New entry '{}' ({} words)", title, word_count))
 }
 
-pub fn journal_update(store: &mut Store, provenance: &str, body: &str, level: Option<i64>) -> Result<String> {
+pub fn journal_update(store: &Store, provenance: &str, body: &str, level: Option<i64>) -> Result<String> {
     let level = level.unwrap_or(0);
     let node_type = level_to_node_type(level);
     let all_keys = store.all_keys()?;
@@ -396,7 +396,7 @@ pub fn graph_communities(store: &Store, _provenance: &str, top_n: Option<usize>,
     Ok(out)
 }
 
-pub fn graph_normalize_strengths(store: &mut Store, _provenance: &str, apply: Option<bool>) -> Result<String> {
+pub fn graph_normalize_strengths(store: &Store, _provenance: &str, apply: Option<bool>) -> Result<String> {
     use crate::store::{StoreView, RelationType};
 
     let apply = apply.unwrap_or(false);