Roadmap for making Type Handlers more strict

[jdrueckert]

Motivation

Currently, most of our type handlers work with a "best effort" approach.
This means for instance, that if a part of a prefab cannot be deserialized, this is (at most) logged but otherwise ignored and the rest of the prefab deserialized as well as possible.
This can lead to weird in-game behavior as some components might be present while others aren't, but there's logic depending on both and not being hardened properly against some components not being present. In addition, it also complicates debugging such weirdness.

By making the serialization/deserialization logic more strict, we can hopefully catch issues earlier and debug them easier.

Proposal

Change the type handling logic to fail when something cannot be serialized/deserialized.
The changes will be mostly done in the engine and its subsystem for type handling.
However, the impact of the changes might well affect module land as well, especially if they unmask issues we currently already have but didn't see due to the best effort approach.

The "definition of done" for this effort is every type handler being adjusted to no longer use a best effort approach but fail with an indicative error message on failure to serialize / deserialize.

Concerns

None so far that come to my mind, but I'm happy about any comments on aspects I might be overlooking at the moment.

* Is there specific expertise that will be needed for this effort?
* Does this effort have dependencies on other efforts?
* Do you expect this effort to conflict with any other efforts?
* What are potential drawbacks of the effort?
* What are maintenance or continuous efforts that will persist beyond the completion of this effort?

Task Breakdown

• List all relevant type handlers that currently use a best effort approach
• Parallelizable: Change the type handler implementation to fail strictly
• Ideally: Increase test coverage for type handlers

* What are the individual tasks that need to be done to complete the effort?
* Can you roughly estimate how hard the individual tasks would be for a software developer with 2 years of on-the-job Java development expertise, but no in-depth expertise in special areas such as rendering or AI?
* Which tasks are inter-dependent?
* Which tasks can be done in parallel?

Additional notes

Feel free to add any other context or screenshots about your roadmap draft here.