fix(0108): break/continue run the loop body's pending defers

lowerBreak/lowerContinue emitted a bare br, and the enclosing block's
emitBlockDefers — seeing the terminator — discarded the pending entries
on the assumption a return had already drained them. The breaking
iteration's defers were silently skipped, leaking whatever the cleanup
released.

Lowering.loop_defer_base records the defer-stack height at each loop's
body start (while / for / range-for, saved and restored alongside
break_target); break/continue drain non-onfail entries down to it in
LIFO order via the non-truncating emitLoopExitDefers before branching.
Truncation stays with the lexical block exits — the same entries still
belong to the fall-through path after the branch containing the break.
break/continue outside a loop now diagnose instead of no-op'ing.

Regression: examples/0049-basic-defer-break-continue.sx (for and while,
break and continue, nested-block LIFO drain).

src/ir/lower/expr.zig

@@ -1793,8 +1793,8 @@ pub fn lowerExpr(self: *Lowering, node: *const Node) Ref {
         .match_expr => |me| self.lowerMatch(&me),
         .while_expr => |we| self.lowerWhile(&we),
         .for_expr => |fe| self.lowerFor(&fe),
-        .break_expr => self.lowerBreak(),
-        .continue_expr => self.lowerContinue(),
+        .break_expr => self.lowerBreak(node.span),
+        .continue_expr => self.lowerContinue(node.span),
         .call => |c| self.lowerCall(&c),
         .ffi_intrinsic_call => |fic| self.lowerFfiIntrinsicCall(&fic),
         .field_access => |fa| self.lowerFieldAccess(&fa, node.span),