fixed if let guards documentation

Author: Kivooeo

src/expressions/match-expr.md

@@ -186,8 +186,6 @@ r[expr.match.if.let.guard.scope]
 * 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
-#![feature(if_let_guard)]
-
 let opt = Some(42);
 
 match opt {
@@ -223,26 +221,23 @@ Before a guard (including an `if let` guard) is evaluated:
       * 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
-      #![feature(if_let_guard)]
-  
       let val = Some(vec![1, 2, 3]);
-  
+
       let result = match val {
           Some(v) if let Some(_) = take(v) => "ok", // ERROR: cannot move out of `v`
           _ => "nope",
       };
-  
+
       ```
-      In the above example, `v` is already bound in the outer pattern, and the guard attempts to move it — this is not allowed. You can fix it by cloning or   borrowing:
+      In the above example, `v` is already bound in the outer pattern, and the guard attempts to move it — this is not allowed. You can fix it by cloning or borrowing:
       ```rust
       Some(v) if let Some(_) = take(v.clone()) => "ok",
       ```
 > [!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
-> #![feature(if_let_guard)]
 > use std::cell::Cell;
-> 
+>
 > let i: Cell<i32> = Cell::new(0);
 > match 1 {
 >     1 | _ if let Some(_) = { i.set(i.get() + 1); Some(1) } => {}