Use auto-differentiation engine

[giordano]

Measurements.jl implements a sort of layman autodifferentiation engine under the hood. It'd be interesting to base it on a more advanced and general autodifferentiation engine (for example I'm particularly curious about Enzyme.jl). We'd basically be able to get rid of all the rules in src/math.jl

[longemen3000]

what do you think about using ChainRules.jl for the rules + some ForwardDiff-style macros to register binary and ternary ops? something like this:

using Measurements: Measurement, gettype
using ChainRulesCore: frule, NoTangent()
macro register_unary(f::Expr)
    return quote
        function $f(a::Measurement)
            fa, dfa = frule((NoTangent(), oneunit(gettype(a))), $f, a)
            return result(fa,dfa,a)
        end
    end |> esc
end

macro register_binary(f::Expr)
    return quote
        function $f(a::Measurement,b::Measurement)
            fab, dfab = frule((NoTangent(), oneunit(gettype(a))), $f, a.val, b.val)
            return result(fab,dfab,(a,b))
        end

        function $f(a::Measurement,b::Real)
            fab, dfab = frule((NoTangent(), oneunit(gettype(a))), $f, a.val, b)
            dfa,dfb = dfab
            return result(fab,dfa,a)
        end

        function $f(a::Real,b::Measurement)
            fab, dfab = frule((NoTangent(), oneunit(gettype(a))), $f, a, b.val)
            dfa,dfb = dfab
            return result(fab,dfb,b)
        end
    end |> esc
end