feat: add optimizer infrastructure and post-lowering structural passes

Add shared optimizer utilities and four post-lowering optimization passes:

**Shared utilities** (optimizer/utils.rs):
- terminator_successors: Get successor blocks for control flow terminators
- build_predecessors: Build predecessor map for dominance analysis
- for_each_use/for_each_use_terminator: Iterate over variable uses in instructions
- instr_dest: Get destination variable of instructions
- set_instr_dest: Redirect instruction output
- replace_uses_of: Variable substitution in instructions
- count_uses_of: Count how many times a variable is used
- is_side_effect_free: Classify instructions

**Post-lowering passes** (run after phi node lowering):
- empty_blocks: Remove passthrough blocks (only Jump, no instructions)
- merge_blocks: Merge single-predecessor blocks with their predecessors
- dead_instrs: Remove unused variable definitions
- dead_blocks: (refactored) Use shared utils

Passes run in multiple iterations to handle cascading opportunities from
each pass (e.g., dead_instrs can create empty blocks).

The optimize_lowered_ir function coordinates these passes on phi-free IR.

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>

Author: bench

crates/herkos-core/src/optimizer/dead_blocks.rs

@@ -4,28 +4,11 @@
 //! arise naturally during IR translation when code follows an `unreachable` or
 //! `return` instruction inside a Wasm structured control flow construct.
 
-use crate::ir::{BlockId, IrBlock, IrFunction, IrTerminator};
+use super::utils::terminator_successors;
+use crate::ir::{BlockId, IrBlock, IrFunction};
 use anyhow::{bail, Result};
 use std::collections::{HashMap, HashSet};
 
-/// Returns the successor block IDs for a terminator.
-fn terminator_successors(term: &IrTerminator) -> Vec<BlockId> {
-    match term {
-        IrTerminator::Return { .. } | IrTerminator::Unreachable => vec![],
-        IrTerminator::Jump { target } => vec![*target],
-        IrTerminator::BranchIf {
-            if_true, if_false, ..
-        } => vec![*if_true, *if_false],
-        IrTerminator::BranchTable {
-            targets, default, ..
-        } => targets
-            .iter()
-            .chain(std::iter::once(default))
-            .copied()
-            .collect(),
-    }
-}
-
 /// Computes the set of block IDs reachable from the entry block via BFS.
 fn reachable_blocks(func: &IrFunction) -> Result<HashSet<BlockId>> {
     // Index blocks by ID for O(1) lookup during traversal.
@@ -61,7 +44,7 @@ pub fn eliminate(func: &mut IrFunction) -> Result<()> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::ir::{IrInstr, IrValue, TypeIdx, VarId, WasmType};
+    use crate::ir::{IrInstr, IrTerminator, IrValue, TypeIdx, VarId, WasmType};
 
     /// Build a minimal `IrFunction` with the given blocks.
     /// Entry block is always `BlockId(0)`.