Real sparsity support in Enzyme backend

Is your feature request related to a problem? Please describe.

The current Enyme implementation doesn't effectively leverage sparsity

Describe the solution you’d like

Something that looks like

if f.hess_prototype === nothing
                vdθ = Tuple((similar(r) for r in eachrow(I(length(θ)) * 1.0)))
                bθ = zeros(length(θ))
                @show bθ
                @show typeof(bθ)
                vdbθ = Tuple(zeros(length(θ)) for i in eachindex(θ))
                @show vdbθ
                @show typeof(vdbθ)
            else
                θ = SparseArrays.sparse(θ)
                @show θ
                vdθ = Tuple((similar(SparseArrays.sparse(r)) for r in eachrow(I(length(θ)) * 1.0)))
                @show vdθ
                @show typeof(vdθ)
                bθ = SparseArrays.similar(θ)
                @show bθ
                @show typeof(bθ)
                vdbθ = Tuple(similar(i) for i in eachrow(f.hess_prototype))
                @show vdbθ
                @show typeof(vdbθ)
            end

will need to be done

Describe alternatives you’ve considered

Maybe an automated sparsity detection version can exist as well but given recent benchmarking it is evident that this needs a rethinking of the way we are doing it

Additional context

Primary benchmark would be the cnlbeam one that already has a working Enzyme implementation. OPF might be worth revisiting with this as well.

cc: @wmoses I guess you'd be interested

Start by locating the current Enzyme backend and its handling of Hessian prototypes, then inspect the cnlbeam benchmark mentioned in the issue; OPF is a possible secondary case. Determine how sparse inputs and derivative containers should be represented, and validate the completed design against the cnlbeam benchmark with sparsity actually leveraged.