This commit implements dead code elimination that works in conjunction
with SCCP to remove unreachable code after constant propagation and
branch folding.

These optimizations target code that becomes dead after constant
propagation, such as:
- Branches with constant conditions (if(1), if(0))
- Instructions that are immediately overwritten
- Unreachable code blocks after branch folding

This extends load/store elimination with more aggressive patterns,
reducing memory traffic by eliminating redundant memory operations.

Local memory optimizations:
- Dead store elimination: Consecutive stores to same location
- Redundant load elimination: Consecutive loads from same location
- Store-to-load forwarding: Replace load with stored value
- Load-store redundancy: Remove store of just-loaded value

Global memory optimizations:
- Global dead store elimination
- Global redundant load elimination

This implements mathematical identity patterns on register operands:
- Self-subtraction: x - x → 0
- Self-XOR: x ^ x → 0
- Self-OR: x | x → x (identity)
- Self-AND: x & x → x (identity)

These patterns emerge after register allocation when different
variables are assigned to the same register. SSA handles constant
folding, peephole handles register-based patterns.

This implements power-of-2 strength reduction patterns:
- Division by 2^n → right shift by n
- Modulo by 2^n → bitwise AND with (2^n - 1)
- Multiplication by 2^n → left shift by n

This optimization is unique to peephole optimizer since SSA
works on virtual registers before actual constants are loaded.

This implements self-comparison optimizations:
- x != x → 0 (always false)
- x == x → 1 (always true)
- x < x → 0 (always false)
- x > x → 0 (always false)
- x <= x → 1 (always true)
- x >= x → 1 (always true)

These register-based patterns appear after register allocation
when different variables are assigned to the same register.
Complements SSA's SCCP constant comparison folding.

This implements bitwise identity and absorption patterns:
- Double complement: ~(~x) → x
- AND with all-ones: x & -1 → x
- OR with zero: x | 0 → x
- XOR with zero: x ^ 0 → x
- AND with zero: x & 0 → 0 (absorption)
- OR with all-ones: x | -1 → -1 (absorption)
- Shift by zero: x << 0 → x, x >> 0 → x

These patterns are not handled by SSA optimizer and provide
significant optimization opportunities for bitwise operations.

This implements 3-instruction sequence optimizations:
- Store-load-store elimination: removes unused intermediate loads
- Consecutive stores: only last store to same location matters