fixed if let guards documentation

Author: Kivooeo

src/expressions/match-expr.md

@@ -157,7 +157,7 @@ r[expr.match.if.let.guard]
 Match arms can include `if let` guards to allow conditional pattern matching within the guard clause. This feature is currently unstable and requires the attribute. It is tracked in issue [#51114](https://github.com/rust-lang/rust/issues/51114).
 
 r[expr.match.if.let.guard.syntax]
-```rust
+```rust,ignore
 match expression {
     pattern if let subpattern = guard_expr => arm_body,
     ...
@@ -170,7 +170,7 @@ When the pattern matches successfully, the `if let` expression in the guard is e
   * If the inner pattern (`subpattern`) matches the result of `guard_expr`, the guard evaluates to `true`.
   * Otherwise, the next arm is tested.
 
-```rust
+```rust,ignore
 let value = Some(10);
 
 let msg = match value {
@@ -184,7 +184,7 @@ r[expr.match.if.let.guard.scope]
 * The `if let` guard may refer to variables bound by the outer match pattern.
 * New variables bound inside the `if let` guard (e.g., `y` in the example above) are available within the body of the match arm where the guard evaluates to `true`, but are not accessible in other arms or outside the match expression.
 
-```rust
+```rust,ignore
 let opt = Some(42);
 
 match opt {
@@ -209,7 +209,7 @@ r[expr.match.if.let.guard.borrowing]
 Before a guard (including an `if let` guard) is evaluated:
   1. Pattern bindings are performed first
       Variables from the outer match pattern (e.g., `x` in `Some(x)`) are bound and initialized. These bindings may involve moving, copying, or borrowing values from   the scrutinee.
-      ```rust
+      ```rust,ignore
       match Some(String::from("hello")) {
           Some(s) if /* guard */ => { /* s is moved here */ }
           _ => {}
@@ -219,7 +219,7 @@ Before a guard (including an `if let` guard) is evaluated:
       * It runs using a shared borrow of the scrutinee
       * You cannot move from the scrutinee inside the guard.
       * New bindings created inside the guard (e.g., via `if let Some(y) = expr`) are local to the guard and do not persist into the match arm body.
-      ```rust
+      ```rust,ignore
       let val = Some(vec![1, 2, 3]);
 
       let result = match val {
@@ -234,7 +234,7 @@ Before a guard (including an `if let` guard) is evaluated:
       ```
 > [!NOTE]
 > Unlike regular if guards, `if let` guards execute only once per match arm, even if the pattern uses the `|` operator to match multiple patterns. This avoids repeated evaluation and potential side effects.
-> ```rust
+> ```rust,ignore
 > use std::cell::Cell;
 >
 > let i: Cell<i32> = Cell::new(0);