Eagerly evaluate scalers rules

Master behavior
```julia
julia> @scalar_rule(one(x), Zero())

julia> frule(one, 1, Zero(), [1, 2])
(1, Zero())

julia> frule(one, 1, Zero(), One())
(1, Zero())
```

Desirable behavior
```julia
julia> @scalar_rule(one(x), Zero())

julia> frule(one, 1, Zero(), [1, 2])
(1, [0, 0])

julia> frule(one, 1, Zero(), One())
(1, Thunk(var"#8#10"())
)
```

Author: YingboMa

src/differential_arithmetic.jl

@@ -57,11 +57,12 @@ end
 Base.:+(a::AbstractThunk, b::AbstractThunk) = unthunk(a) + unthunk(b)
 Base.:*(a::AbstractThunk, b::AbstractThunk) = unthunk(a) * unthunk(b)
 for T in (:Any,)
-    @eval Base.:+(a::AbstractThunk, b::$T) = unthunk(a) + b
-    @eval Base.:+(a::$T, b::AbstractThunk) = a + unthunk(b)
+    # we want to eagerly compute the result when thunk meets other types
+    @eval Base.:+(a::AbstractThunk, b::$T) = extern(a) + b
+    @eval Base.:+(a::$T, b::AbstractThunk) = a + extern(b)
 
-    @eval Base.:*(a::AbstractThunk, b::$T) = unthunk(a) * b
-    @eval Base.:*(a::$T, b::AbstractThunk) = a * unthunk(b)
+    @eval Base.:*(a::AbstractThunk, b::$T) = extern(a) * b
+    @eval Base.:*(a::$T, b::AbstractThunk) = a * extern(b)
 end
 
 ################## Composite ##############################################################

src/rule_definition_tools.jl

@@ -209,7 +209,8 @@ function propagation_expr(Δs, ∂s)
     # This is basically Δs ⋅ ∂s
     ∂s = map(esc, ∂s)
 
-    ∂_mul_Δs = ntuple(i->:($(∂s[i]) * $(Δs[i])), length(∂s))
+    # this is neccssary since we want to eagerly evaluate the result
+    ∂_mul_Δs = [:(@thunk($(∂s[i])) * $(Δs[i])) for i in 1:length(∂s)]
     return :(+($(∂_mul_Δs...)))
 end