feat(ble): Android backend — BleIo over a Kotlin-radio byte-bridge

The Android BLE radio lives in Kotlin, so AndroidIo/Stream/Acceptor/Scanner
implement BleIo by delegating to AndroidBleBridge — the channel machinery shared
with the JNI layer in the embedder. The AndroidRadio trait is the object-safe
command surface Kotlin implements (listen/connect/advertise/scan/close).

- Inbound bytes/events are pushed non-blocking into tokio channels
  (deliver_recv/inbound/scan/connect_result); outbound bytes are pulled by a
  per-channel Kotlin writer thread via next_send. BleStream::send never calls
  JNI — the byte hot path is pure channel push.
- Per-peer PSM: connect() substitutes the learned PSM; advertising emits the
  OS-assigned listener PSM (16-bit LE service-data).
- Wired as DefaultBleTransport on Android, plus a node construction arm that
  reads the embedder-injected bridge (set_android_ble_bridge).

Pure Rust (no JNI here — that's in myco-core), so the channel logic unit-tests
on the host with a mock radio. Cross-compiles clean for arm64-android.

src/node/mod.rs

@@ -1043,6 +1043,43 @@ impl Node {
             }
         }
 
+        // Android BLE: the radio lives in Kotlin; build AndroidIo over the bridge
+        // injected by the embedder (see ble::android_io::set_android_ble_bridge).
+        #[cfg(all(target_os = "android", not(test)))]
+        {
+            let ble_instances: Vec<_> = self
+                .config()
+                .transports
+                .ble
+                .iter()
+                .map(|(name, config)| (name.map(|s| s.to_string()), config.clone()))
+                .collect();
+            match crate::transport::ble::android_io::android_ble_bridge() {
+                Some(bridge) => {
+                    for (name, ble_config) in ble_instances {
+                        let transport_id = self.allocate_transport_id();
+                        let io = crate::transport::ble::android_io::AndroidIo::new(
+                            std::sync::Arc::clone(&bridge),
+                        );
+                        let mut ble = crate::transport::ble::BleTransport::new(
+                            transport_id,
+                            name,
+                            ble_config,
+                            io,
+                            packet_tx.clone(),
+                        );
+                        ble.set_local_pubkey(self.identity().pubkey().serialize());
+                        transports.push(TransportHandle::Ble(ble));
+                    }
+                }
+                None => {
+                    if !ble_instances.is_empty() {
+                        tracing::warn!("BLE configured but no Android radio bridge injected");
+                    }
+                }
+            }
+        }
+
         transports
     }