[SIL.rst] Cleanup docs on explicit_copy_value.

There really isn't a point in repeating the verbage from copy_value. So I
removed that and just referred back to the copy_value documentation and focused
instead on what makes explicit_copy_value different semantically from
copy_value, how it is used to work around the invariant in Canonical SIL that
move only typed values can not be copied. This is useful for:

1. Implementing an explicit copy for no implicit copy types.

2. When the move checker errors since it can't produce a move only solution for
a value, we change all of the copies into explicit_copy_value. We need some sort
of copy to ensure later once we are in Canonical SIL, Ownership SSA is correct
/and/ we maintain the no copy of move only typed values in Canonical SIL.

Author: gottesmm

Diff for: docs/SIL.rst

@@ -5594,27 +5594,18 @@ explicit_copy_value
 
    %1 = explicit_copy_value %0 : $A
 
-Performs a copy of a loadable value as if by the value's type lowering and
-returns the copy. The returned copy semantically is a value that is completely
-independent of the operand. In terms of specific types:
-
-1. For trivial types, this is equivalent to just propagating through the trivial
-   value.
-2. For reference types, this is equivalent to performing a ``strong_retain``
-   operation and returning the reference.
-3. For ``@unowned`` types, this is equivalent to performing an
-   ``unowned_retain`` and returning the operand.
-4. For aggregate types, this is equivalent to recursively performing a
-   ``copy_value`` on its components, forming a new aggregate from the copied
-   components, and then returning the new aggregate.
-
-In ownership qualified functions, a ``explicit_copy_value`` produces a +1 value
-that must be consumed at most once along any path through the program.
-
-When move only variable checking is performed, ``explicit_copy_value`` is
+This is exactly the same instruction semantically as `copy_value`_ with the
+exception that when move only checking is performed, `explicit_copy_value`_ is
 treated as an explicit copy asked for by the user that should not be rewritten
 and should be treated as a non-consuming use.
 
+This is used for two things:
+
+1. Implementing a copy builtin for no implicit copy types.
+2. To enable the move checker, once it has emitted an error diagnostic, to still
+   produce valid Ownership SSA SIL at the end of the guaranteed optimization
+   pipeline when we enter the Canonical SIL stage.
+
 move_value
 ``````````