perf: speed up constant string joins

[He-Pin]

Motivation:

std.join over repeated constant string arrays (for example std.join('', std.repeat(['e'], n))) currently walks every element and repeatedly appends the same separator/value pair. This PR keeps the optimization focused on that repeated/constant-array case while preserving Jsonnet laziness and null-skipping behavior.

Key Design Decision

Expose a best-effort constantEval from array views and use it only when std.join can prove every element is the same already-known string or null. If the element is lazy, non-string, or otherwise unsafe to inspect eagerly, the code falls back to the existing element-by-element join path.

Modification:

• Add constant/repeated array views for repeated values.
• Fast-path string std.join for constant/repeated string arrays with exact result sizing.
• Preserve existing pre-sized array-copy behavior for array separators.
• Add directional golden coverage for repeated strings, Unicode strings, null skipping, array joins, and zero-length lazy-error behavior.

Benchmark Results:

JMH on JDK 21, ./mill -j 1 bench.runRegressions ..., lower ms/op is better; ops/ms = 1 / ms_per_op, higher is better.

Case	master ms/op	PR ms/op	master ops/ms	PR ops/ms	Delta
cpp_suite/bench.09.jsonnet	0.041	0.037	24.39	27.03	+10.8% ops/ms
cpp_suite/large_string_join.jsonnet	0.547	0.252	1.83	3.97	+117.1% ops/ms
sjsonnet_suite/array_copy_views.jsonnet guard rerun	7.770	7.677	0.129	0.130	+1.2% ops/ms

Scala Native hyperfine, lower is better, comparing locally built Scala Native binaries and source-built jrsonnet 0.5.0-pre98.

Case	master	PR	jrsonnet	Result
scaled repeated join (std.repeat(['abcd'], 50000))	8.1 ± 1.2 ms	6.9 ± 1.0 ms	4.8 ± 1.2 ms	PR is ~14.8% faster than master; still ~1.44x jrsonnet
cpp_suite/large_string_join.jsonnet	7.0 ± 1.2 ms	5.5 ± 1.0 ms	5.2 ± 0.9 ms	PR is ~21.4% faster than master; roughly at jrsonnet parity
cpp_suite/bench.09.jsonnet tiny CLI run	6.5 ± 1.7 ms	8.3 ± 1.3 ms	5.7 ± 0.8 ms	startup/noise dominated; superseded by scaled repeated-join run above

Analysis:

The semantic guard is intentionally conservative: only already-constant string/null elements take the new direct materialization path. Lazy errors are not forced early, as covered by std.join('-', std.repeat([error 'unused'], 0)). Non-constant arrays and array-separator joins retain the existing master behavior.

References:

• PR: perf: speed up constant string joins #825
• Rebased head: ce421ff5fa002eaae136d5241b08d34685ba04d2
• Base: 0ae7b78a93c4e643f9bcfb6dd1d99d9fe7a522a9

Result:

• ./mill -j 1 __.reformat && ./mill -j 1 __.test passed locally.
• PR comments were reviewed; there are no review threads. The maintainer request was to rebase this PR one-at-a-time, which this update addresses.

[He-Pin]

Closing as superseded by #828, which carries the TOML and repeated join work with current docs-aligned benchmark data.

[He-Pin]

Reopened and moved back to draft rather than closing. It is not negative, but it is currently superseded by #828, so it should not be ready for review unless we decide to keep it as a separate smaller join-only PR.

[stephenamar-db]

rebase

[stephenamar-db]

Let's do it one at a time here - please rebase this one and I'll merge

[He-Pin]

Rebased onto latest master and refreshed the local validation/benchmark data in the PR description. I also added directional golden coverage for repeated constant joins.

[He-Pin]

@stephenamar-db I have rebased ,sorry for many conflicts