refactor: shrinks Value from 96 to 24 bytes

[claymcleod]

While investigating Sprocket's baseline memory usage, I noticed that certain workloads—particularly those involving deeply nested compound types like Map[String, Map[String, ...]]—scaled poorly. The root cause was the Value enum in wdl-engine, which occupied 96 bytes per element due to large inline types (Type at 56 bytes, TaskPostEvaluationValue at 96 bytes) inflating the enum even though the common case (PrimitiveValue) is only 16 bytes.

This refactor pushes Arc wrapping down into the types that inflate Value. Each compound value type (Array, Map, Pair, Struct, EnumVariant) and each large hidden value type (TaskPreEvaluation, TaskPostEvaluation) becomes a thin wrapper around Arc<Inner>, where the inner struct owns all fields directly—eliminating nested Arc layering. Two new wrapper types (NoneValue and TypeNameRefValue) handle variants that previously stored a bare Type. CallValue wraps its CallType field behind Arc as well.

The tradeoff is an additional pointer indirection when accessing fields of compound and hidden values, since their data now lives behind Arc on the heap rather than inline in the enum. In practice, this cost is negligible: these types were already heap-allocated internally (e.g., Array stored an Arc<Vec<Value>>), so the refactor consolidates rather than adds indirection. Clone remains cheap—a refcount bump on one Arc rather than multiple.

A const assertion prevents Value from exceeding 24 bytes in the future. The as_map standard library function was also updated to use the IndexMap entry API, eliminating a redundant key clone.

Benchmarked on an Apple M3 Max against the prior version across five synthetic workloads:

Benchmark	Before RSS	After RSS	Memory reduction	Before time	After time
Nested arrays (1K, 2^10)	36 MB	34 MB	-6%	0.05s	0.04s
Nested arrays (59K, 3^10)	300 MB	243 MB	-19%	0.63s	0.58s
Flat array (1M strings)	549 MB	423 MB	-23%	4.50s	3.52s
Nested arrays (1M, 4^10)	3,578 MB	2,980 MB	-17%	8.93s	8.45s
Nested maps (1M, 32^4)	3,731 MB	2,457 MB	-34%	11.76s	11.06s

The improvement is most pronounced for nested maps because each map entry stores a Value for the key and a Value for the nested map, so the 4x per-element reduction compounds across all four nesting levels. Flat arrays benefit less because only one Array container exists—the savings come from shrinking each element Value within its backing Vec.

For all contributors:

• You have not used AI on any parts of this pull request.
• You have added a few sentences describing the PR here.
• Your code builds clean without any errors or warnings.
• You have added tests (when appropriate).

[claymcleod]

This is more of a correctness sidequest rather than a performance improvement. In the case where the key is not in the map, we can avoid the preemptive clone of the key.

[claymcleod]

I took the approach that WDL None values should be referred to as "none" to disambiguate it from Rust's None value.

[claymcleod]

Unlike name, every caller of this just constructed an IndexMap and immediately wrapped it with an Arc. So the original Arc was truly just for making this cheaply clonable.

[peterhuene]

Looks great, just one minor nit!

[peterhuene]

I think this could just be a call to repeat as CallArgument should probably be Clone:

Suggested change

	let mut arguments: [CallArgument; MAX_PARAMETERS] =
	std::array::from_fn(|_| CallArgument::none());
	let mut arguments: [CallArgument; MAX_PARAMETERS] =
	std::array::repeat(CallArgument::none()));

[peterhuene]

I also meant to approve my previous review as the nit comment isn't that big a deal either.