You can use this property is to enable cheaper object construction. Say I have a group of object types that I frequently create together, and I want to be able to produce a new instance of the group quickly. In other words, every time I make an X I also need to make a Y and a Z. If you know the constituents of the group at compile time, you just put them all in a struct and clone/construct when needed. But what if you only know the types going into the group at run time, because say it is based on a configuration file? You can have a list of function pointers that are constructors to call, but totally dynamic function calls are not particularly fast.
One way to enable this is to have a "template" of bytes saved somewhere that you know if you memcpy will give you all the objects in the group in in a valid state, located contiguously one after the other. This way the only thing that is dynamic is exactly how many bytes you copy. But this can only work in instances where you are sure the types in the template are safe to bitwise copy.
Copy can guarantee that, but is overly restrictive because some types that can't always be safely copied can still be safely copied if they are in a certain state (e.g. a 0 capacity vector). If there were a guarantee like this around standard containers like this I could just count on using them, but as is it seems like I should probably just create my own unsafe trait to represent this property (