feat(android): wire Android Keystore JNI via OnceLock

Remove the dependency on bevy::android::ANDROID_APP inside
android_keystore.rs. Instead, solitaire_data owns a process-wide
OnceLock<JavaVM> initialised by a new pub fn init_android_jvm().
solitaire_app calls it from android_main before run() so JNI is
ready before any auth-token operation can execute.

- android_keystore: drop ANDROID_APP import; add ANDROID_JVM OnceLock
  and init_android_jvm(vm_ptr: *mut c_void)
- solitaire_data/lib.rs: re-export init_android_jvm for android target
- auth_tokens.rs: update doc comment (Android backend is now complete)
- solitaire_app/lib.rs: call init_android_jvm from android_main

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

solitaire_data/src/android_keystore.rs

@@ -19,11 +19,14 @@ use jni::{
 };
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
+use std::ffi::c_void;
 use std::path::PathBuf;
+use std::sync::OnceLock;
 
 use crate::auth_tokens::TokenError;
 
 const KEY_ALIAS: &str = "ferrous_solitaire_token_key";
+static ANDROID_JVM: OnceLock<JavaVM> = OnceLock::new();
 
 #[derive(Serialize, Deserialize)]
 struct TokenBlob {
@@ -36,17 +39,37 @@ struct TokenBlob {
 // JVM helper
 // ---------------------------------------------------------------------------
 
+/// Initialise Android Keystore access with the process-wide `JavaVM*`.
+///
+/// This is called by `solitaire_app` from Android startup code. Keeping the
+/// raw JVM pointer here avoids making `solitaire_data` depend on the app or
+/// engine layer just to reach platform startup state.
+pub fn init_android_jvm(vm_ptr: *mut c_void) -> Result<(), TokenError> {
+    if vm_ptr.is_null() {
+        return Err(TokenError::KeychainUnavailable(
+            "JavaVM pointer is null".into(),
+        ));
+    }
+    if ANDROID_JVM.get().is_some() {
+        return Ok(());
+    }
+
+    // SAFETY: `vm_ptr` is supplied by Android startup code and must be the
+    // process-wide JavaVM* for this app. `OnceLock` keeps the wrapper alive for
+    // the process lifetime.
+    let vm = unsafe { JavaVM::from_raw(vm_ptr.cast()) }
+        .map_err(|e| TokenError::Keyring(format!("JavaVM: {e}")))?;
+    let _ = ANDROID_JVM.set(vm);
+    Ok(())
+}
+
 fn with_jvm<F, R>(f: F) -> Result<R, TokenError>
 where
     F: for<'env> FnOnce(&mut JNIEnv<'env>) -> Result<R, jni::errors::Error>,
 {
-    let app = bevy::android::ANDROID_APP
+    let vm = ANDROID_JVM
         .get()
-        .ok_or_else(|| TokenError::KeychainUnavailable("ANDROID_APP not initialised".into()))?;
-
-    // SAFETY: vm_as_ptr() is the process-wide JavaVM* set by the Android runtime.
-    let vm = unsafe { JavaVM::from_raw(app.vm_as_ptr().cast()) }
-        .map_err(|e| TokenError::Keyring(format!("JavaVM: {e}")))?;
+        .ok_or_else(|| TokenError::KeychainUnavailable("Android JavaVM not initialised".into()))?;
 
     let mut env = vm
         .attach_current_thread_permanently()