docs: Keep only what Core's tutorial lacks

The guide's offline-signing section repeated Bitcoin Core's tutorial
with QR transport added. Moving public wallet data by QR is Bails's
job, not this library's, so the section goes back to what the tutorial
lacks: restore offline_wallet with ms32 wallet, then follow the
tutorial, now linked on master.

Say the signer goes offline before it is restored and stays offline,
so it need not have been offline its whole life. Drop the "QR tools
below" sentence and the QR troubleshooting section, which no step
uses.

Refs #92

Claude-Session: https://claude.ai/code/session_01T233rKgZqE5wzDm3EVTHL1

Author: claude

docs/user/guide.md

@@ -81,8 +81,7 @@ port.
 
 Use a computer you believe is malware-free and whose other software you trust.
 Only codex32 and Bitcoin Core should perform recovery, derivation, wallet
-initialization, or signing. The QR tools below transport only public
-descriptors, PSBTs, and signed transactions.
+initialization, or signing.
 
 Bitcoin Core wallet encryption is strongly recommended. Bitcoin Core owns the
 passphrase and its prompts; codex32 never asks for, reads, or forwards it.
@@ -192,133 +191,16 @@ worth the extra steps.
 
 ## More protection: watch-only wallet and offline signer
 
-This setup follows Bitcoin Core v32's
-[offline-signing tutorial](https://github.com/bitcoin/bitcoin/blob/v32.0rc1/doc/offline-signing-tutorial.md)
-and its two wallets: `offline_wallet` holds the signing keys on a computer that
-never connects to a network, and `watch_only_wallet` runs on an ordinary online
-node. Where the tutorial carries a file between the computers, this guide shows
-the same public data as a QR on one screen and scans it with the other
-computer's camera.
+On the offline signer, create an empty encrypted descriptor wallet with private
+keys enabled and run `ms32 wallet`. Take that computer and its USB stick offline
+before you restore the signer, and keep them offline for good.
 
-Before disconnecting the offline computer for good, install Bitcoin Core and
-codex32. Both computers also use `python3`, `gzip`, `qr`, and ZBar's
-`zbarcam`, which Tails already includes. Disable Ethernet, internet, Tor, Wi-Fi,
-Bluetooth, cellular, and every other network path on the offline computer.
-
-### 1. Restore the offline signer
-
-On the offline computer, create an empty encrypted descriptor wallet named
-`offline_wallet` with private keys enabled and run `ms32 wallet`. Keep that
-computer disconnected from every network while recovery text or signing keys
-are present.
-
-### 2. Create the online watch-only wallet
-
-The tutorial moves a watch-only wallet file made by `exportwatchonlywallet`.
-That file does not fit in a QR even compressed, so send the public descriptors
-instead, compressed with `gzip`. On the offline computer:
-
-```bash
-bitcoin-cli -rpcwallet=offline_wallet listdescriptors |
-  python3 -c 'import json, sys; print(json.dumps(json.load(sys.stdin)["descriptors"]), end="")' |
-  gzip -9 | qr
-```
-
-The compressed descriptors take about 640 bytes; see
-[QR troubleshooting](#qr-troubleshooting) if the QR does not fit. Public
-descriptors cannot spend, but they reveal wallet activity. Do not use a
-website, cloud scanner, chat service, or synced clipboard.
-
-On the online computer, create a blank watch-only wallet, then scan and
-decompress the QR into it:
-
-```bash
-bitcoin-cli -named createwallet wallet_name=watch_only_wallet disable_private_keys=true blank=true
-zbarcam --raw --oneshot -Sdisable -Sqrcode.enable -Sbinary | gunzip |
-  bitcoin-cli -rpcwallet=watch_only_wallet -stdin importdescriptors
-```
-
-Every result must say `"success": true`. Core's descriptor export keeps the
-stored timestamps, so the online node rescans from the same point. Run
-`getnewaddress` in each wallet and compare the two addresses on the two
-screens. Do not receive funds if they differ.
-
-### 3. Receive to a checked address
-
-Get receiving addresses and set labels in `watch_only_wallet`, as the tutorial
-does, so one wallet tracks which addresses are used. Malware on the online
-computer could show an address it controls, so check every address on the
-offline computer before giving it out. On the online computer:
-
-```bash
-bitcoin-cli -rpcwallet=watch_only_wallet getnewaddress "LABEL" | qr
-```
-
-On the offline computer, scan it and look it up in the signing wallet:
-
-```bash
-address=$(zbarcam --raw --oneshot -Sdisable -Sqrcode.enable)
-bitcoin-cli -rpcwallet=offline_wallet getaddressinfo "$address"
-```
-
-Give out the address only if the result shows `"ismine": true`. This works
-while `offline_wallet` is locked. The offline wallet recognizes its first 1,000
-addresses of each type; past that, a real address shows `"ismine": false` until
-you unlock `offline_wallet` and run `keypoolrefill` with a larger number.
-
-When you pay yourself from a phone wallet, or the payer is with you, show the
-checked address as a QR on the offline screen and scan it there; nothing needs
-comparing:
-
-```bash
-printf %s "$address" | qr
-```
-
-For an exchange withdrawal or a payer over the internet, the address must pass
-through a networked computer or phone, where malware could swap it after the
-check. Paste it there, then compare the address on the last screen before you
-submit or send, such as the exchange's confirmation page or your sent message,
-character by character with the `"address"` shown offline.
-
-### 4. Spend with a PSBT
-
-On the online computer, create the unsigned PSBT with your destination and
-amount, and show it as a QR:
-
-```bash
-bitcoin-cli -rpcwallet=watch_only_wallet send '{"DESTINATION_ADDRESS": AMOUNT}' |
-  python3 -c 'import json, sys; print(json.load(sys.stdin)["psbt"], end="")' > funded_psbt.txt &&
-  qr < funded_psbt.txt
-```
-
-On the offline computer, scan it, then check every destination, amount, and
-fee before signing:
-
-```bash
-zbarcam --raw --oneshot -Sdisable -Sqrcode.enable > funded_psbt.txt
-bitcoin-cli decodepsbt "$(cat funded_psbt.txt)"
-bitcoin-cli analyzepsbt "$(cat funded_psbt.txt)"
-```
-
-Unlock `offline_wallet` as the tutorial shows, then sign and show the signed
-transaction as a QR:
-
-```bash
-bitcoin-cli -rpcwallet=offline_wallet walletprocesspsbt "$(cat funded_psbt.txt)" |
-  python3 -c 'import json, sys; r = json.load(sys.stdin); print(r["hex"] if r["complete"] else sys.exit("The PSBT is not fully signed."), end="")' > final_psbt.txt &&
-  qr < final_psbt.txt
-```
-
-On the online computer, scan it and broadcast:
-
-```bash
-zbarcam --raw --oneshot -Sdisable -Sqrcode.enable > final_psbt.txt
-bitcoin-cli sendrawtransaction "$(cat final_psbt.txt)"
-```
-
-If a PSBT is too large for a reliable QR, use a dedicated removable drive. The
-drive crosses the security boundary: keep it for this purpose, treat every file
-on it as untrusted, and still verify the transaction on the offline screen.
+After the signer is restored, follow Bitcoin Core's maintained
+[offline-signing tutorial](https://github.com/bitcoin/bitcoin/blob/master/doc/offline-signing-tutorial.md).
+That workflow owns the watch-only export/import and PSBT transport steps. In
+Bitcoin Core v32, `exportwatchonlywallet` creates the watch-only wallet file and
+`restorewallet` loads it on the online node. Do not improvise a codex32-specific
+descriptor-transfer procedure in place of that maintained workflow.
 
 ## Recover an existing or inherited wallet
 
@@ -348,8 +230,8 @@ its public wallet data with the separate wallet record.
    It gives Core the master private key, asks Core to create the standard
    account-0 descriptors, scans history, and relocks an encrypted wallet.
 6. If you need an online watch-only counterpart, keep the restored signer
-   offline and follow Bitcoin Core v32's
-   [offline-signing tutorial](https://github.com/bitcoin/bitcoin/blob/v32.0rc1/doc/offline-signing-tutorial.md)
+   offline and follow Bitcoin Core's
+   [offline-signing tutorial](https://github.com/bitcoin/bitcoin/blob/master/doc/offline-signing-tutorial.md)
    to export and restore the watch-only wallet. Let the online node synchronize,
    then compare the recovered fingerprint, account, policy, addresses, balance,
    and transaction history with the wallet record.
@@ -410,15 +292,6 @@ Keep the matching application worksheet and original wallet instructions with
 the inheritance plan. Published BIP-93 still defines the `ms` application; the
 arbitrary-HRP format direction is not yet merged into that specification.
 
-### QR troubleshooting
-
-Maximize the terminal and reduce its font size if a QR does not fit. Keep `qr`
-connected to the terminal; redirecting its output creates an image file.
-Reading the compressed descriptors needs ZBar 0.23.1 or newer for `-Sbinary`;
-without it, ZBar rewrites the bytes as text and `gunzip` fails. Only public
-descriptors, xpubs, PSBTs, and signed transactions may cross the offline
-boundary by QR.
-
 ## Technical references
 
 Automation, low-level private exports, parser behavior, correction mathematics,