Design a binomial tree option pricer using the Cox-Ross-Rubinstein model.

Module name: binom_pricer
Parameters:
  - WIDTH   = 32       // Total bit width
  - FRAC    = 16       // Fractional bits (Q16.16 fixed-point)
  - N_STEPS = 8        // Number of time steps in the binomial tree

Ports:
  - input                        clk
  - input                        rst_n        // Active-low synchronous reset
  - input  signed [WIDTH-1:0]    spot         // Spot price (Q16.16)
  - input  signed [WIDTH-1:0]    strike       // Strike price (Q16.16)
  - input  signed [WIDTH-1:0]    up_factor    // Up movement factor u (Q16.16)
  - input  signed [WIDTH-1:0]    down_factor  // Down movement factor d (Q16.16)
  - input  signed [WIDTH-1:0]    discount     // Per-step discount factor (Q16.16)
  - input                        is_call      // 1 = call option, 0 = put option
  - input                        valid_in     // Asserts for one cycle with new inputs
  - output signed [WIDTH-1:0]    option_price // Computed option price (Q16.16)
  - output                       valid_out    // Asserts for one cycle when result is ready

Functional specification:
  - Implements Cox-Ross-Rubinstein binomial tree pricing:
    1. Compute risk-neutral probability p = (1/discount - d) / (u - d)
       (Here discount is per-step, so 1/discount approximates exp(r*dt))
    2. Build terminal node payoffs: for node j (j=0..N_STEPS),
       asset_price = spot * u^j * d^(N_STEPS-j)
       payoff = max(0, asset_price - strike) for call
       payoff = max(0, strike - asset_price) for put
    3. Backward induction from step N to step 0:
       V(j) = discount * (p * V(j+1) + (1-p) * V(j))
    4. Final option_price = V(0) at step 0
  - Store N_STEPS+1 values in register array, update in-place backward
  - Sequential, multi-cycle computation
  - All arithmetic in signed Q16.16 fixed-point

Knobs:
  - N_STEPS: [4, 8, 16] — more steps = more accuracy but more cycles
  - WIDTH: [24, 32] — precision vs area tradeoff

Critical IO: valid_in -> valid_out (sequential, latency depends on N_STEPS)
