Remove SumNode/ProdNode, use Node2 chains via reduce(+/*) instead

exa_sum now folds children with reduce(+, ...) producing a tree of
Node2{typeof(+)}, and exa_prod uses reduce(*, ...) for Node2{typeof(*)}.
This reuses the existing registered +/* dispatch for all three passes
(primal, adjoint, second-adjoint) without needing dedicated node types.

Empty iterators return Null(0) / Null(1) respectively.

https://claude.ai/code/session_01QsVaXnG1Cw7LdtCzvVYRoo

Author: claude

src/graph.jl

@@ -318,67 +318,3 @@ end
 @inline (v::Null{Nothing})(i, x::SecondAdjointNodeSource{T}, θ) where {T} = SecondAdjointNull(zero(eltype(T)))
 @inline (v::Null{N})(i, x::SecondAdjointNodeSource{T}, θ) where {N, T} = SecondAdjointNull(eltype(T)(v.value))
 
-# ── SumNode / ProdNode ────────────────────────────────────────────────────────
-
-"""
-    SumNode{I} <: AbstractNode
-
-A node representing the sum of a tuple of child nodes.
-
-Constructed by [`exa_sum`](@ref).  Within `@obj`, `@con`, and `@expr` macros,
-`sum(body for k in range)` is automatically rewritten to
-`exa_sum(k -> body, Val(range))` with the `Val` hoisted outside the generator
-closure for type stability under `juliac --trim=safe`.
-
-In adjoint / second-adjoint mode the children are evaluated and folded via
-`reduce(+, …)` (or `reduce(*, …)` for [`ProdNode`](@ref)), reusing the existing
-registered `+` / `*` dispatch.  No dedicated adjoint node types are needed.
-"""
-struct SumNode{I} <: AbstractNode
-    inners::I
-end
-
-"""
-    ProdNode{I} <: AbstractNode
-
-A node representing the product of a tuple of child nodes.
-
-Constructed by [`exa_prod`](@ref).  See [`SumNode`](@ref) for design notes.
-"""
-struct ProdNode{I} <: AbstractNode
-    inners::I
-end
-
-# ── Primal evaluation (x::AbstractVector → scalar) ───────────────────────────
-
-@inline (n::SumNode{Tuple{}})(i, x::V, θ) where {T, V<:AbstractVector{T}} = zero(T)
-@inline (n::SumNode)(i, x::V, θ) where {T, V<:AbstractVector{T}} =
-    mapreduce(inner -> inner(i, x, θ), +, n.inners)
-
-@inline (n::ProdNode{Tuple{}})(i, x::V, θ) where {T, V<:AbstractVector{T}} = one(T)
-@inline (n::ProdNode)(i, x::V, θ) where {T, V<:AbstractVector{T}} =
-    mapreduce(inner -> inner(i, x, θ), *, n.inners)
-
-# ── Adjoint tree (gradient) ───────────────────────────────────────────────────
-
-@inline (n::SumNode{Tuple{}})(i, x::AdjointNodeSource{VT}, θ) where {VT} =
-    AdjointNull(zero(eltype(VT)))
-@inline (n::SumNode)(i, x::AdjointNodeSource, θ) =
-    reduce(+, map(inner -> inner(i, x, θ), n.inners))
-
-@inline (n::ProdNode{Tuple{}})(i, x::AdjointNodeSource{VT}, θ) where {VT} =
-    AdjointNull(one(eltype(VT)))
-@inline (n::ProdNode)(i, x::AdjointNodeSource, θ) =
-    reduce(*, map(inner -> inner(i, x, θ), n.inners))
-
-# ── Second-adjoint tree (Hessian) ─────────────────────────────────────────────
-
-@inline (n::SumNode{Tuple{}})(i, x::SecondAdjointNodeSource{VT}, θ) where {VT} =
-    SecondAdjointNull(zero(eltype(VT)))
-@inline (n::SumNode)(i, x::SecondAdjointNodeSource, θ) =
-    reduce(+, map(inner -> inner(i, x, θ), n.inners))
-
-@inline (n::ProdNode{Tuple{}})(i, x::SecondAdjointNodeSource{VT}, θ) where {VT} =
-    SecondAdjointNull(one(eltype(VT)))
-@inline (n::ProdNode)(i, x::SecondAdjointNodeSource, θ) =
-    reduce(*, map(inner -> inner(i, x, θ), n.inners))

src/simdfunction.jl

@@ -178,11 +178,3 @@ end
 @inline replace_T(t, n::Null{T}) where T <: Real = Null{t}(t(n.value))
 @inline replace_T(::Type{T1}, n::T2) where {T1, T2 <: Real} = T1(n)
 @inline replace_T(::Type{T1}, ::Val{V}) where {T1, V} = Val(T1(V))
-@inline function replace_T(t, n::SumNode{I}) where {I}
-    inners = map(x -> replace_T(t, x), n.inners)
-    SumNode(inners)
-end
-@inline function replace_T(t, n::ProdNode{I}) where {I}
-    inners = map(x -> replace_T(t, x), n.inners)
-    ProdNode(inners)
-end

src/specialization.jl

@@ -247,10 +247,11 @@ end
     exa_sum(f, ::Val{range})
     exa_sum(gen::Base.Generator)
 
-Build a [`SumNode`](@ref) representing `∑ f(k)` for `k ∈ itr`. Inside `@obj`,
-`@con`, and `@expr` macros, `sum(body for k in range)` is automatically
-rewritten to `exa_sum(k -> body, Val(range))` with the `Val` hoisted outside
-the generator closure.
+Build a node tree representing `∑ f(k)` for `k ∈ itr`, folded via `+` into
+a chain of `Node2{typeof(+)}`. Inside `@obj`, `@con`, and `@expr` macros,
+`sum(body for k in range)` is automatically rewritten to
+`exa_sum(k -> body, Val(range))` with the `Val` hoisted outside the generator
+closure.
 
 # Supported iterators
 - `Tuple`: type-stable via tail recursion.
@@ -268,23 +269,24 @@ v = Val(1:nc)                                          # outside generator
 c, con = add_con(c, (exa_sum(j -> x[j], v) for i in 1:nh))  # v captured
 ```
 """
-@inline exa_sum(f, ::Tuple{}) = SumNode(())
-@inline exa_sum(f, t::Tuple) = SumNode(_exa_map(f, t))
+@inline exa_sum(f, ::Tuple{}) = Null(0)
+@inline exa_sum(f, t::Tuple) = reduce(+, _exa_map(f, t))
 
 """
     exa_prod(f, itr)
     exa_prod(f, ::Val{range})
     exa_prod(gen::Base.Generator)
 
-Build a [`ProdNode`](@ref) representing `∏ f(k)` for `k ∈ itr`. Inside `@obj`,
-`@con`, and `@expr` macros, `prod(body for k in range)` is automatically
-rewritten to `exa_prod(k -> body, Val(range))` with the `Val` hoisted outside
-the generator closure.
+Build a node tree representing `∏ f(k)` for `k ∈ itr`, folded via `*` into
+a chain of `Node2{typeof(*)}`. Inside `@obj`, `@con`, and `@expr` macros,
+`prod(body for k in range)` is automatically rewritten to
+`exa_prod(k -> body, Val(range))` with the `Val` hoisted outside the
+generator closure.
 
 See [`exa_sum`](@ref) for supported iterators and juliac usage notes.
 """
-@inline exa_prod(f, ::Tuple{}) = ProdNode(())
-@inline exa_prod(f, t::Tuple) = ProdNode(_exa_map(f, t))
+@inline exa_prod(f, ::Tuple{}) = Null(1)
+@inline exa_prod(f, t::Tuple) = reduce(*, _exa_map(f, t))
 
 # ── UnitRange{Int}: Val{N}-based recursion ────────────────────────────────────
 
@@ -305,10 +307,10 @@ end
 end
 
 @inline _exa_sum_range(f, lo::Int, ::Val{N}) where {N} =
-    SumNode(ntuple(i -> f(lo + i - 1), Val{N}()))
+    reduce(+, ntuple(i -> f(lo + i - 1), Val{N}()))
 
 @inline _exa_prod_range(f, lo::Int, ::Val{N}) where {N} =
-    ProdNode(ntuple(i -> f(lo + i - 1), Val{N}()))
+    reduce(*, ntuple(i -> f(lo + i - 1), Val{N}()))
 
 # ── Generator form (direct use outside macro) ─────────────────────────────────