config: global writable AppConfig; learn settings live there

Runtime-mutable settings (F6's threshold knob, the generate-alternates
toggle, anything else that comes along) were ending up as mirrored
fields on MindState — each new config setting grew MindState::new's
signature and added a clone+sync path. Wrong home. MindState is
ephemeral session state, not a config projection.

Give AppConfig the same treatment the memory Config has: install it
into a global RwLock<AppConfig> at startup via load_app, read through
config::app() (returns a read guard), mutate through update_app. The
config_writer functions now write to disk AND update the cache
atomically, so the one-stop-shop call keeps both in sync.

Also while in here:

- learn.generate_alternates moves from a sentinel file
  (~/.consciousness/cache/finetune-alternates, "exists = enabled")
  into the config under the learn section. On first run with this
  build, if the sentinel file still exists Mind::new flips the
  config value to true and removes it. Drops
  alternates_enabled()/set_alternates().

- Default threshold 0.0000001 → 1.0. With the timestamp filter
  removed the previous value was letting essentially everything
  through; 1.0 is a sane "nothing gets through unless you actually
  want it" default.

- score_finetune_candidates takes generate_alternates as a parameter
  instead of reading a global — caller snapshots the config values
  once at the top of start_finetune_scoring so the async task
  doesn't need to hold the config read lock across awaits.

- MindState.learn_threshold / learn_generate_alternates gone; the
  SetLearn* command handlers now just delegate to config_writer.

Kent noted RwLock<Arc<AppConfig>> (the pattern used by the memory
Config global) is pointless here — nobody needs a snapshot-after-
release, reads are short — so this uses a plain RwLock<AppConfig>
and returns a read guard.

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

src/config_writer.rs

@@ -140,7 +140,17 @@ fn parse_scalar_literal(literal: &str) -> Result<JSONValue> {
 /// Convenience: set `learn.threshold` to the given f64.
 pub fn set_learn_threshold(value: f64) -> Result<()> {
     // {:e} gives the minimal scientific notation that preserves the value.
-    set_scalar("learn", "threshold", &format!("{:e}", value))
+    set_scalar("learn", "threshold", &format!("{:e}", value))?;
+    crate::config::update_app(|app| app.learn.threshold = value);
+    Ok(())
+}
+
+/// Convenience: set `learn.generate_alternates` to the given bool.
+pub fn set_learn_generate_alternates(value: bool) -> Result<()> {
+    set_scalar("learn", "generate_alternates",
+        if value { "true" } else { "false" })?;
+    crate::config::update_app(|app| app.learn.generate_alternates = value);
+    Ok(())
 }
 
 #[cfg(test)]