apple: encryption-service oracle API for wrapping-key access

[jgowdy-godaddy]

Summary

Shrinks the wrapping-key exposure surface without changing user-visible
behavior. The process-local TTL cache from #77 still serves the same
role, but the raw 32-byte AES key no longer crosses the
`keychain_wrap` module boundary.

Why

The caller in #77 looked like:

```rust
// keychain.rs::load_handle — hot path, runs on every sign
let wrapping_key = keychain_wrap::keychain_load(app, label, ttl)?;
crate::keychain_wrap::decrypt_blob(&wrapping_key, &contents)
```

The raw AES key lived in at least three places during each sign:
the cache entry (intended, `mlock`ed, zeroized), the `Result`
return value (transient, not zeroized), and `decrypt_blob`'s local
binding (transient). A log statement, serialization mistake, or
overeager clone in any caller could leak it.

Change

Public API from `keychain_wrap` is three functions that perform the
crypto internally and return only the result:

• `generate_and_wrap(app, label, plaintext, use_user_presence)
  -> Result<Vec>` — create key, store with access-control
  policy, encrypt plaintext, return wrapped blob. Rolls back the
  keychain entry on intermediate failure.
• `decrypt_with_cached_key(app, label, blob, cache_ttl)
  -> Result<Option<Vec>>` — consult cache, keychain on miss
  (prompts on userPresence items), return only the decrypted
  plaintext.
• `relabel_wrapping_key(app, old, new, use_user_presence)
  -> Result<()>` — atomically move an entry from one label to
  another. Raw key is loaded, re-stored, and old entry deleted all
  inside the function.

The old helpers that exposed raw bytes (`keychain_store`,
`keychain_load`, `generate_wrapping_key`, `encrypt_blob`,
`decrypt_blob`) are now `pub(crate)` — still callable from the
crate's own tests and the keychain.rs module, no longer part of the
library surface.

Callers in `keychain.rs` updated:

• `generate_and_save_key` → `generate_and_wrap`.
• `rename_key` → `relabel_wrapping_key` + simpler disk-then-keychain
  ordering with symmetric rollback.
• `load_handle` → `decrypt_with_cached_key`.

Threat model delta

Stops a caller-level memory-disclosure bug from spilling the wrapping
key. Doesn't change anything for a `task_for_pid` / ptrace attacker
with live-memory read access; they were always going to win against
any SSH agent, same as before.

Test plan

• `cargo test --workspace` — all passing.
• `cargo clippy --workspace --all-targets -- -D warnings` clean.
• `cargo fmt --all -- --check` clean.
• sshenc-side dependent build: compiles on the existing
  `wrapping-key-user-presence` branch; no sshenc changes needed — the
  new oracle API is a drop-in on the sshenc side via
  `SshencBackend` which already goes through `AppSigningBackend`
  → `SecureEnclaveSigner` → `keychain.rs`. sshenc sees the
  decrypted handle as before; it never saw the raw wrapping key.