This is true, but it's only half the story, and i think it's the less interesting half.
As you can say, you can make a type copy by asking the compiler to derive(Copy). But the compiler will only do this if all the fields in the struct are themselves Copy [1].
Primitives (integers, floats, booleans, chars) are Copy; shared (aka immutable) references are copy; tuples and arrays containing only Copy types are Copy. Structs and enums declared to be Copy are Copy (as long as they only contain Copy fields).
But exclusive (aka mutable) references are not copy: Rust's safety guarantees depend on there only being one instance of an exclusive pointer to something (hence the name). Unique, which wraps a raw pointer, is also not Copy, because the whole point of it is to mark a pointer as unique. Unique underlies Box, Vec, and String, so those are also not Copy.
So, user-defined types are copyable only if they explicitly opt-in and it is actually safe to copy them.
As an aside, smart pointer types like Rc are also not Copy, but not for structural reasons: the one field in a Rc is Copy. But Rc itself being Copy would defeat the object of actually counting references, so it is not declared Copy.
[1] https://doc.rust-lang.org/std/marker/trait.Copy.html#when-ca...
This is very helpful, because you know you can't copy something expensive by accident.
It comes handy in libraries. Zero-sized non-copyable objects with destructors can be used as lock guards/handles that control exclusive access to a shared resource.