Documentation for `Clone` is inaccurate w/r/t large arrays (always?) not implementing `Clone`.

[chordowl]

Currently, the Clone docs state that Clone is not implemented for arrays with more than 32 elements:

rust/src/libcore/clone.rs

Lines 73 to 89 in 3eeb5a6

	/// An example is an array holding more than 32 elements of a type that is `Clone`; the standard
	/// library only implements `Clone` up until arrays of size 32. In this case, the implementation of
	/// `Clone` cannot be `derive`d, but can be implemented as:
	///
	/// [`Copy`]: ../../std/marker/trait.Copy.html
	/// [`clone`]: trait.Clone.html#tymethod.clone
	///
	/// ```
	/// #[derive(Copy)]
	/// struct Stats {
	/// frequencies: [i32; 100],
	/// }
	///
	/// impl Clone for Stats {
	/// fn clone(&self) -> Stats { *self }
	/// }
	/// ```

This seems to be untrue, at least for the given example: playground. This must've been the case since at least 1.21.0.

I would fix this myself, but unfortunately, from the PR linked in the changelog, I'm not quite sure in which circumstances Clone is now auto-implemented. I didn't just want to rip out the example without providing a new one that makes more sense for the current situation.

Edit: to prevent this from happening again, it might be nice to have an additional compile_fail-style example in the docs to show what doesn't work, so that doctests can catch it.

[steveklabnik]

Yes, this was changed at some point...

[steveklabnik]

Tagging as E-hard simply because we need to track down what the answer is; once that's done it will be E-easy.

[jonas-schievink]

Triage:

The Clone docs say:

In addition to the implementors listed below, the following types also implement Clone:
...

• Array types, for all sizes, if the item type also implements Clone (e.g., [i32; 123456])

The array primitive docs say:

Arrays of any size are Copy if the element type is Copy and Clone if the element type is Clone. This works because Copy and Clone traits are specially known to the compiler.

Closing as fixed.