`push!!` fails for typed VarInfo when two `VarName`s have the same symbol but different type

[penelopeysm]

This means, for example, it is impossible to fill a typed VarInfo for models like this (instead you have to fill an untyped VarInfo and then only convert it to a typed VarInfo):

julia> using DynamicPPL, Distributions

julia> @model function f()
           x = (; a = undef, b = undef)
           x.a ~ Normal()
           x.b ~ Normal()
       end
f (generic function with 2 methods)

julia> DynamicPPL.init!!(f(), DynamicPPL.typed_varinfo(VarInfo()), InitFromPrior())
ERROR: MethodError: Cannot `convert` an object of type
  VarName{x,Accessors.PropertyLens{b}} to an object of type
  VarName{x,Accessors.PropertyLens{a}}
The function `convert` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  convert(::Type{T}, ::T) where T
   @ Base Base.jl:126

Stacktrace:
  [1] setindex!(h::Dict{VarName{:x, Accessors.PropertyLens{:a}}, Int64}, v0::Int64, key0::VarName{:x, Accessors.PropertyLens{:b}})
    @ Base ./dict.jl:346
  [2] push!(meta::DynamicPPL.Metadata{Dict{…}, Vector{…}, Vector{…}, Vector{…}}, vn::VarName{:x, Accessors.PropertyLens{…}}, r::Float64, dist::Normal{Float64})
    @ DynamicPPL ~/ppl/dppl/src/varinfo.jl:1734
  [3] push!!(vi::VarInfo{@NamedTuple{…}, DynamicPPL.AccumulatorTuple{…}}, vn::VarName{:x, Accessors.PropertyLens{…}}, r::Float64, dist::Normal{Float64})
[...]

An even smaller repro:

julia> vi = DynamicPPL.typed_varinfo(VarInfo());

julia> vi = push!!(vi, @varname(x.a), 1.0, Normal());

julia> vi = push!!(vi, @varname(x.b), 2.0, Normal())
ERROR: MethodError:
[...]

[penelopeysm]

I think this might mostly be a case of using BangBang.push!! somewhere instead of ordinary push!, but I'm not sure about potential implications on performance / type stability etc

[penelopeysm]

The last time this came up was in the context of initialisation and whether it was better to initialise on untyped then convert to typed, or do it the other way round. So I decided to run some tests:

using DynamicPPL, Distributions, Chairmarks, LinearAlgebra

y = [28, 8, -3, 7, -1, 1, 18, 12]
sigma = [15, 10, 16, 11, 9, 11, 10, 18]
@model function eight_schools(y, sigma)
    mu ~ Normal(0, 5)
    tau ~ truncated(Cauchy(0, 5); lower=0)
    theta ~ MvNormal(fill(mu, length(y)), tau^2 * I)
    for i in eachindex(y)
        y[i] ~ Normal(theta[i], sigma[i])
    end
    return (mu=mu, tau=tau)
end

model1 = eight_schools(y, sigma)

@model function many()
    a1 ~ Normal()
    a2 ~ Normal()
    a3 ~ Normal()
    a4 ~ Normal()
    a5 ~ Normal()
    a6 ~ Normal()
    a7 ~ Normal()
    a8 ~ Normal()
    a9 ~ Normal()
    a10 ~ Normal()
    a11 ~ Normal()
    a12 ~ Normal()
    a13 ~ Normal()
    a14 ~ Normal()
    a15 ~ Normal()
    a16 ~ Normal()
    a17 ~ Normal()
    a18 ~ Normal()
    a19 ~ Normal()
    a20 ~ Normal()
end

model2 = many()

# Initialise on untyped, then convert to typed
DynamicPPL.typed_varinfo(last(DynamicPPL.init!!(model1_or_model2, VarInfo())))

# Directly initialise on typed
last(DynamicPPL.init!!(model1_or_model2, DynamicPPL.typed_varinfo(VarInfo())))

Here are the results:

	model1 (3 params)	model2 (20 params)
Init on untyped: compile	1.315 s	3.717 s
Init on typed: compile	0.885 s	7.414 s
Init on untyped: run	34.896 µs, 351 allocs	429.500 μs, 2367 allocs
Init on typed: run	3.667 µs, 95 allocs	213.250 μs, 1814 allocs

So I think it's generally in line with expectations. Runtime is much faster on typed varinfo, but the compile time scales poorly with the number of variables. Since initialisation is often only done once at the beginning of sampling, runtime doesn't really matter, which means that compile time is probably the main consideration here.