Accelerate connection sets merging with union-find

Baseline:
```julia
julia> @time run_and_time_julia!(ss_times, times, max_sizes, 1, 100)
  0.960393 seconds (8.15 M allocations: 540.022 MiB, 4.47% gc time)
0.888558584

julia> @time run_and_time_julia!(ss_times, times, max_sizes, 1, 200)
  2.593054 seconds (17.95 M allocations: 1.131 GiB, 3.75% gc time)
2.465012458

julia> @time run_and_time_julia!(ss_times, times, max_sizes, 1, 300)
  5.065673 seconds (29.41 M allocations: 1.821 GiB, 5.90% gc time)
4.861177375
```

PR:
```julia
julia> @time run_and_time_julia!(ss_times, times, max_sizes, 1, 100);
  0.748587 seconds (7.61 M allocations: 513.135 MiB, 7.15% gc time)

julia> @time run_and_time_julia!(ss_times, times, max_sizes, 1, 200);
  1.681521 seconds (15.75 M allocations: 1.027 GiB, 7.71% gc time)

julia> @time run_and_time_julia!(ss_times, times, max_sizes, 1, 300);
  2.931254 seconds (24.43 M allocations: 1.590 GiB, 11.97% gc time)
```

Author: YingboMa

src/systems/connectors.jl

@@ -187,6 +187,7 @@ end
 struct ConnectionSet
     set::Vector{ConnectionElement} # namespace.sys, var, isouter
 end
+ConnectionSet() = ConnectionSet(ConnectionElement[])
 Base.copy(c::ConnectionSet) = ConnectionSet(copy(c.set))
 
 function Base.show(io::IO, c::ConnectionSet)
@@ -373,51 +374,38 @@ function generate_connection_set!(connectionsets, domain_csets,
 end
 
 function Base.merge(csets::AbstractVector{<:ConnectionSet}, allouter = false)
-    csets, merged = partial_merge(csets, allouter)
-    while merged
-        csets, merged = partial_merge(csets)
-    end
-    csets
-end
-
-function partial_merge(csets::AbstractVector{<:ConnectionSet}, allouter = false)
-    mcsets = ConnectionSet[]
     ele2idx = Dict{ConnectionElement, Int}()
-    cacheset = Set{ConnectionElement}()
-    merged = false
-    for (j, cset) in enumerate(csets)
-        if allouter
-            cset = ConnectionSet(map(withtrueouter, cset.set))
-        end
-        idx = nothing
-        for e in cset.set
-            idx = get(ele2idx, e, nothing)
-            if idx !== nothing
-                merged = true
-                break
+    idx2ele = ConnectionElement[]
+    union_find = IntDisjointSets(0)
+    prev_id = Ref(-1)
+    for cset in csets, (j, s) in enumerate(cset.set)
+        v = allouter ? withtrueouter(s) : s
+        id = let ele2idx = ele2idx, idx2ele = idx2ele
+            get!(ele2idx, v) do
+                push!(idx2ele, v)
+                id = length(idx2ele)
+                id′ = push!(union_find)
+                @assert id == id′
+                id
             end
         end
-        if idx === nothing
-            push!(mcsets, copy(cset))
-            for e in cset.set
-                ele2idx[e] = length(mcsets)
-            end
-        else
-            for e in mcsets[idx].set
-                push!(cacheset, e)
-            end
-            for e in cset.set
-                push!(cacheset, e)
-            end
-            empty!(mcsets[idx].set)
-            for e in cacheset
-                ele2idx[e] = idx
-                push!(mcsets[idx].set, e)
-            end
-            empty!(cacheset)
+        if j > 1
+            union!(union_find, prev_id[], id)
+        end
+        prev_id[] = id
+    end
+    id2set = Dict{Int, ConnectionSet}()
+    merged_set = ConnectionSet[]
+    for (id, ele) in enumerate(idx2ele)
+        rid = find_root(union_find, id)
+        set = get!(id2set, rid) do
+            set = ConnectionSet()
+            push!(merged_set, set)
+            set
         end
+        push!(set.set, ele)
     end
-    mcsets, merged
+    merged_set
 end
 
 function generate_connection_equations_and_stream_connections(csets::AbstractVector{