Improve DynamicValue error handling

[Godzilla675]

Fixes #480

Summary

• add DynamicValue.toTypedValueAccumulating as a backward-compatible accumulating API
• accumulate decode errors across records, tuples, sequences, sets, and dictionary entries
• add focused DynamicValueSpec coverage for success-path parity and multi-error accumulation

Validation

• testsJVM/testOnly zio.schema.DynamicValueSpec
• zioSchemaJVM/scalafmtCheck
• testsJVM/scalafmtCheck

/claim #480

[Copilot]

Pull request overview

Adds an accumulating decode API for DynamicValue that can collect multiple decode errors (rather than failing fast) and extends test coverage to validate success-path parity and multi-error accumulation.

Changes:

• Introduce DynamicValue.toTypedValueAccumulating backed by an accumulating Validation-based decoder.
• Accumulate decode errors across tuples, sequences, sets, maps, and record structures.
• Add DynamicValueSpec tests for parity on successful decodes and for multi-error accumulation scenarios.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 5 comments.

File	Description
zio-schema/shared/src/main/scala/zio/schema/DynamicValue.scala	Adds accumulating decode API and record-structure accumulating decoder.
tests/shared/src/test/scala/zio/schema/DynamicValueSpec.scala	Adds focused tests for accumulating behavior and success-path parity.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

decodeStructureAccumulating folds over values.keySet, which can (a) miss schema fields that are absent from values (so missing-field / incompatible-shape errors won’t be accumulated), and (b) produce a record map in an order unrelated to structure. This is particularly problematic for Schema.Record[A] decoding, where s.construct(Chunk.fromIterable(m.values)) is typically positional and expects schema-field ordering. A concrete fix is to drive decoding primarily from structure (preserving field order and detecting missing values), and separately detect/accumulate errors for unexpected extra keys in values.

[Copilot]

Chunk appends via (_ :+ _) can lead to quadratic behavior for large sequences because repeated appends may copy increasingly large chunks. Prefer accumulating into a builder/collection with efficient append (or accumulate in reverse with prepend-then-reverse) and convert once at the end, while still using Validation to accumulate errors.

Suggested change

	.foldLeft[Validation[DecodeError, Chunk[t]]](Validation.succeed(Chunk.empty)) { (acc, value) =>
	acc.zipWithPar(
	value.toTypedValueAccumulatingLazyError(schema.elementSchema)
	)(_ :+ _)
	}
	.map(schema.fromChunk)
	.foldLeft[Validation[DecodeError, List[t]]](Validation.succeed(List.empty[t])) { (acc, value) =>
	acc.zipWithPar(
	value.toTypedValueAccumulatingLazyError(schema.elementSchema)
	)((list, elem) => elem :: list)
	}
	.map { reversedList =>
	schema.fromChunk(Chunk.fromIterable(reversedList.reverse))
	}

[Copilot]

Using assertTrue(false) on the failure branch discards useful failure information and makes debugging harder. Prefer asserting directly on the Validation shape/value using ZIO Test assertions (e.g., assert that it is Success with the expected value), so failures report the collected errors.

[Copilot]

This PR adds new accumulating behavior for SetValue and Dictionary element decoding, but the new DynamicValueSpec cases only cover record/tuple/sequence accumulation. Add tests that demonstrate multiple independent failures are accumulated for sets and maps as well (e.g., multiple bad keys/values and multiple bad set elements), to validate the newly introduced branches.

[Copilot]

This PR adds new accumulating behavior for SetValue and Dictionary element decoding, but the new DynamicValueSpec cases only cover record/tuple/sequence accumulation. Add tests that demonstrate multiple independent failures are accumulated for sets and maps as well (e.g., multiple bad keys/values and multiple bad set elements), to validate the newly introduced branches.