Mutable datatypes can break observability

Is your feature request related to a problem? Please describe.
A DataProperty typed as a dict may have its value changed without triggering __set__. This leads to the property's value becoming out of sync with observers.

Describe the solution you'd like
DataProperty instances that are typed as a mutable object (e.g. dict, list, or a custom class) should either not be observable, or should raise an error when they are defined (or once the type is resolved).

For mapping or sequence types, I think it would be really nice to have the error message suggest typing them as Mapping or Sequence. Type checked code should then not allow mutation of these objects. We could even use a MappingProxy for dict values to ensure they don't get mutated, or convert list to tuple to achieve the same effect.

I think this merits a bit of discussion. Observability isn't something that's used much at the moment, but I can see it becoming important, for example in efficient client implementations. I would be keen to make sure that it works properly.

Describe alternatives you've considered
I've previously attempted to implement a deep reactive dictionary. This does not seem like a good idea: there are far too many things to go wrong.

Start by locating the DataProperty implementation and the observability behavior around set. Compare the proposed handling for mutable dict, list, and custom-class types, including Mapping and Sequence annotations. Done requires a decided policy and corresponding validation or non-observable behavior, but the issue does not identify tests or settle which alternative to implement.