quadratic (?) complexity when composing fragments

Concatenating 10k Fragments 10 times is much faster than concatenating 100k fragments one time. This suggests a quadratic (or nonlinear) runtime complexity.

Reproduction in ammonite (Scala 2.13.8):

import $ivy.`org.tpolecat::skunk-core:0.2.3`; import skunk._; import skunk.implicits._

def measure(code: => Any) = {val start = System.nanoTime; code; println(f"${(System.nanoTime - start)/1000000000.0}%.2fs")}

measure { for(i <- 0 until 10) Array.fill(10000)(sql"x").foldLeft(sql"")((a,b) => sql"$a$b") }
// 18s
// is much faster than
measure { Array.fill(100000)(sql"x").foldLeft(sql"")((a,b) => sql"$a$b") }
// 213s

It could be caused by repeated concatenation of a growing List.

Run the provided Ammonite reproduction with skunk-core 0.2.3 first and compare the two concatenation patterns. Then locate the Fragment composition implementation and trace how the growing result is assembled. Done means identifying and addressing the nonlinear scaling while preserving the existing composition behavior, with measurements or regression coverage for large inputs.