core: write a material parameter in place, without invalidating bound references

[petlenz]

Adds material_interface::set_parameter<T>(), so a caller can change a material's parameter after construction and have the material see it — a UMAT re-reading PROPS between increments, a driver sweeping a modulus, a test varying one input without rebuilding the graph.

The branch predates the plasticity split and the UMAT layer; main is merged in here. The only collision was tests/CMakeLists.txt (both sides append a test registration). 274/274 tests pass, verified locally against the merge result.

What it does

Assigns through the non-const get<T>(), not insert(). insert_or_assign replaces the whole std::any, which relocates anything past its small-buffer — invalidating every reference a material bound at construction, which is how every material reads its parameters.

T is deliberately not deduced. std::type_identity_t makes the stored type an explicit argument, so set_parameter<double>("K", 250) compiles and set_parameter("K", 250) does not. Deduced, that literal was an int, threw std::bad_any_cast, and silently lost the write — and bad_any_cast derives from neither invalid_argument nor runtime_error, so a UMAT boundary catching those would miss it entirely and terminate. A surviving mismatch (set_parameter<float> against a stored double) is translated into an invalid_argument naming the key.

Writing "name" is rejected: the identity is cached in m_name at construction and used as the material_handler registry key, so a write left the parameter disagreeing with both — name() and lookups kept the old value while get_parameter<std::string>("name") reported one that resolved to nothing.

What it deliberately does not do

A write reaches only what the material re-reads through its bound reference. It does not touch anything derived at construction, copied into a member, or consumed once for wiring, and it is local to one material because each holds its own copy of the handler.

That is a real limitation, and the reason it is stated so precisely is that the original test suite hid it: every case went through a probe material that binds each parameter by reference and derives nothing — exactly the shape the API handles cleanly. Three tests now use shipped materials and pin the awkward behaviour instead:

test	what it pins
WriteLandsButDerivedStateGoesStale	linear_elasticity: K changes, stress does not
WriteIsLocalToTheMaterial	the caller's handler keeps the old value
WritingAWiringKeyDoesNotRewire	a source name written after finalize() leaves the input wired as before

Both fixes are mutation-verified: removing the "name" check and breaking the bad_any_cast translation each fail exactly their own test.

One note for review

The doc comment's original wording pointed at a recompute-style tangent as the mitigation for the staleness above, and noted no such class existed. One does now — isotropic_tangent (#28) rebuilds on every update with no memo. It sources K/G from other materials rather than from its own parameters, so it is not directly the set_parameter path, but it may be the better answer for a caller who wants a live modulus, and the comment could say so.