It’s worth bearing in mind that the mutability semantics of Julia and Rust come from different language families. Rust offers immutable or limited mutable references to objects, Julia objects themselves have immutable or mutable types. The ability to mutate _value::T means T is a mutable type (or if we speak more flexibly about mutation API, it could be a wrapper of one), and we access mutable instances solely by what are effectively unlimited mutable references. We just don’t have the kind of control to pull off to_mut for a single type.
Julia also doesn’t have Rust’s automatic Deref coercion, which seemlessly unwraps Cow<T> for methods taking immutable references to T. If you use a wrapper type in Julia, you either have to unwrap it manually first or you reimplement a bunch of methods to do it before repeating the call, and there’s no protection from mutation of a mutable T.
The closest thing to protection from mutation is sharing an instance of an immutable type. The user can be forced to use a method to deep-copy to a mutable type for mutation, call it to_mut if you like. To share instead of copy the data of an immutable instance (like if you assign it to an inlined element or field), you’d need to wrap it in something like the mutable Ref, though you’d also need to do your best to obstruct the user from reassigning it. On top of that, you’d need to reimplement non-mutating methods for both the Ref-ed immutable version and mutable version.