fix(parser): parse braced defer { … } body as a statement block (issue 0065)

A braced `defer` body routed through `parseExpr` + a mandatory trailing
`;`, so it parsed the `{ … }` as a block-EXPRESSION whose statement loop
doesn't handle a destructure decl or a `catch`-statement — `defer { v, e
:= f(); … }` and `defer { x() catch e … }` failed with "expected ';'",
and even `defer { stmt; }` needed a spurious trailing semicolon.

Now the `kw_defer` arm parses a braced body with `parseBlock` (the same
path `onfail` uses), so every statement form works; the bare-expression
form (`defer expr;`) is unchanged. `in_defer_body` is still set before
parsing, so the cleanup-body control-flow bans (return/break/continue/
try/raise) and the E1.7 failable-absorption check still fire.

Resolves the `defer` manifestation of issue 0065 (the general
value-block-in-binding-position destructure remains open). Regression:
examples/1050-errors-defer-block-body.sx.

Gates: zig build, zig build test, run_examples.sh -> 341 passed, 0 failed.

src/parser.zig

@@ -2019,15 +2019,23 @@ pub const Parser = struct {
             return try self.createNode(start, .{ .return_stmt = .{ .value = value } });
         }
 
-        // Defer statement: defer <expr>;
+        // Defer statement: defer { body } | defer <expr>;
+        // A braced body parses as a full statement block (like `onfail`), so it
+        // supports every statement form (destructure, `catch`-statement, …); the
+        // bare-expression form keeps its trailing `;`.
         if (self.current.tag == .kw_defer) {
             const start = self.current.loc.start;
             self.advance();
             const saved_defer = self.in_defer_body;
             self.in_defer_body = true;
             defer self.in_defer_body = saved_defer;
-            const deferred = try self.parseExpr();
-            try self.expect(.semicolon);
+            const deferred: *Node = if (self.current.tag == .l_brace)
+                try self.parseBlock()
+            else blk: {
+                const e = try self.parseExpr();
+                try self.expect(.semicolon);
+                break :blk e;
+            };
             return try self.createNode(start, .{ .defer_stmt = .{ .expr = deferred } });
         }