Confirm the print path on a real P1P, and stop discarding its answer

Print control (pause/resume/stop) and print start are now both confirmed
against the P1P on the LAN, and doing that turned up three real defects.

`start_uploaded_file` published fire-and-forget, so the printer's reply was
thrown away. Asking it to print a file it does not have returned `Ok(())`,
and watching `print.push_status` could not tell that apart from a successful
start, since both leave the machine IDLE for a while. The printer does in
fact answer - `{"command":"gcode_file","param":"...","reason":"error
string","result":"fail"}` - and it echoes the `sequence_id` we send, so
`request` correlates it. Both this and `control_print` now go out as
correlated requests and run the reply through `print_command_outcome`.

The upload and the print command disagreed about where files live. `upload`
cwd'd into `cache/` while the printable projects are in the card's root: the
root holds 43 `<name>.gcode.3mf` archives, `cache/` holds the printer's own
extracted `<project>_plate_N.gcode` working copies with `.gcode.bbl`
sidecars. Those extracted copies are not independently printable -
`gcode_file` with `param: "/cache/Cube_plate_1.gcode"` was rejected for a
file the FTPS listing shows is right there - while `project_file` with
`url: "ftp:///Cube.gcode.3mf"` started a print. So the destination is now a
parameter and both halves point at `SD_ROOT`.

What the hardware settled, recorded in the doc comments: the `ftp:///` url
spelling is right, `param: "Metadata/plate_1.gcode"` works for a
single-plate project, `use_ams: false` + `ams_mapping: ""` is accepted, and
a stop during PREPARE/RUNNING moves the printer to FAILED, which is how
Bambu reports an operator cancellation. What it did not settle: all three
control verbs answer `result: "success"` on an *idle* printer, so the reply
means "accepted", not "the state changed" - callers still have to read
`gcode_state` back.

`PrinterCommand::ControlPrint` makes this reachable from the cloud at all;
until now pause/resume/stop existed in the proxy with no way to send them.
Still no start-print variant, now for a different reason: the path around it
is missing, not the hardware proof.

Also: `list_dir` for any directory (how the layout above was found, without
sending a print command to guess), `request_raw` for probing an unconfirmed
command shape, and two examples - `bambu_cache_list` (read-only) and
`bambu_print_probe` (gated steps, `start` needing both IDLE and
--yes-start-a-real-print).

examples/bambu_cache_list.rs

@@ -0,0 +1,89 @@
+//! Run with: cargo run --example bambu_cache_list -- <printer-id> [dir]
+//!
+//! `dir` defaults to `cache`; pass `/` to see the SD card root, which is
+//! how to find out what a file's real absolute path is.
+//!
+//! **Read-only.** Connects, reads one `print.push_status`, and lists the
+//! printer's `cache/` directory over FTPS. It sends no commands that change
+//! anything - the `pushall` it issues is a request for a status report, which
+//! is the one write-shaped thing a read-only tool has to do on a v1 printer
+//! to learn anything at all.
+//!
+//! The point of it: `start_uploaded_file` can only print a file that is
+//! already in `cache/`, so this answers "is there anything there, and what is
+//! it called?" before any print command is sent. It is also how to find a
+//! real slicer-produced `.3mf` to test that command against, which is worth
+//! a great deal more than a hand-built one - if a hand-built file fails there
+//! is no way to tell whether the command was wrong or the file was.
+
+use std::time::Duration;
+
+use continuum_proxy::fleet;
+use continuum_proxy::printer::{GenericPrinter, PrinterHandle};
+
+const CONNECT_TIMEOUT: Duration = Duration::from_secs(20);
+const STATUS_TIMEOUT: Duration = Duration::from_secs(15);
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let Some(target) = std::env::args().nth(1) else {
+        anyhow::bail!("usage: cargo run --example bambu_cache_list -- <printer-id> [dir]");
+    };
+    let dir = std::env::args().nth(2).unwrap_or_else(|| "cache".to_string());
+
+    let mut printers = fleet::load(std::path::Path::new("printers.toml"))?;
+    let printer = printers
+        .iter_mut()
+        .find(|p| p.base().id == target)
+        .ok_or_else(|| anyhow::anyhow!("no printer with id '{target}' in printers.toml"))?;
+
+    let PrinterHandle::Bambu(bambu) = printer else {
+        anyhow::bail!("'{target}' is not a Bambu printer - this example is Bambu-specific");
+    };
+
+    println!("=== {} ===", bambu.display_name());
+
+    match tokio::time::timeout(CONNECT_TIMEOUT, bambu.connect()).await {
+        Ok(Ok(())) => {}
+        Ok(Err(err)) => anyhow::bail!("connect failed: {err}"),
+        Err(_) => anyhow::bail!("connect timed out - printer off or unreachable?"),
+    }
+
+    bambu.pushall().await.ok();
+
+    let deadline = tokio::time::Instant::now() + STATUS_TIMEOUT;
+    loop {
+        if let Some(report) = bambu.print_status().await {
+            if let Some(state) = report.gcode_state.clone() {
+                println!("  gcode_state:   {state}");
+                println!("  subtask_name:  {}", report.subtask_name.clone().unwrap_or_default());
+                println!(
+                    "  layer:         {}/{}",
+                    report.layer_num.unwrap_or_default(),
+                    report.total_layer_num.unwrap_or_default()
+                );
+                println!("  percent:       {}", report.mc_percent.unwrap_or_default());
+                break;
+            }
+        }
+        if tokio::time::Instant::now() >= deadline {
+            println!("  (no gcode_state within {STATUS_TIMEOUT:?} - listing cache/ anyway)");
+            break;
+        }
+        tokio::time::sleep(Duration::from_millis(500)).await;
+    }
+
+    println!("\n  {dir} over FTPS:");
+    match bambu.list_dir(&dir).await {
+        Ok(entries) if entries.is_empty() => println!("    (empty)"),
+        Ok(entries) => {
+            for entry in &entries {
+                println!("    {entry}");
+            }
+            println!("\n  {} entr(ies)", entries.len());
+        }
+        Err(err) => println!("    FAILED: {err}"),
+    }
+
+    Ok(())
+}