Lint: clippy's collapsible_match passes on Rust 1.95

cargo +1.95 clippy --workspace --all-targets --release -- -D warnings
stopped on seven `if` blocks that clippy wants folded into their match
arm (psd, text, effects x2, pdf x2, render). Each becomes a match guard.
The behaviour is unchanged: when a guard is false the value falls through
to arms that can't match it and then to `_ => {}`. The one exception is
the PDF PostScript calculator, where a `{` past the nesting limit would
fall through to the operator arm; it keeps its own no-op arm, so it is
still skipped rather than pushed as an operator.

crates/pdf/src/color.rs

@@ -221,11 +221,9 @@ fn ps_parse(lx: &mut crate::object::Lexer, depth: usize) -> Vec<PsOp> {
         match o {
             Obj::Num(n) => out.push(PsOp::Num(n)),
             Obj::Bool(b) => out.push(PsOp::Num(if b { 1.0 } else { 0.0 })),
-            Obj::Op(op) if op == "{" => {
-                if depth < 32 {
-                    out.push(PsOp::Proc(ps_parse(lx, depth + 1)));
-                }
-            }
+            Obj::Op(op) if op == "{" && depth < 32 => out.push(PsOp::Proc(ps_parse(lx, depth + 1))),
+            // Nested too deep: skip the procedure's opening brace (never push it as an operator).
+            Obj::Op(op) if op == "{" => {}
             Obj::Op(op) if op == "}" => return out,
             Obj::Op(op) => out.push(PsOp::Op(op)),
             _ => {}

crates/pdf/src/page.rs

@@ -313,11 +313,9 @@ impl<'a> Interp<'a> {
                     self.path.curve_to(Point::new(n(0), n(1)), p, p);
                     self.cur = Some(p);
                 }
-                "h" => {
-                    if self.cur.is_some() {
-                        self.path.close_path();
-                        self.cur = self.start;
-                    }
+                "h" if self.cur.is_some() => {
+                    self.path.close_path();
+                    self.cur = self.start;
                 }
                 "re" => {
                     let (x, y, w, h) = (n(0), n(1), n(2), n(3));