Revise ...discriminants.slice-patterns-* rules

The section here stated:

> Matching against a slice pattern that needs to inspect the length of
> the scrutinee performs a read of the pointer value in order to fetch
> the length. The read will cause the closure to borrow the relevant
> place by `ImmBorrow`.

It then goes on to state exceptions for arrays matched against slice
patterns and slice patterns containing only a rest pattern.

In saying that the pointer value is read, this might suggest that the
pointer is captured.  Actually, though, it's the slice (the pointee)
that is captured.  Let's fix this.

Beyond that, as we saw in an earlier commit, it's better to not lean
on the reader to infer the "relevant place" or when the length needs
to be inspected.  Let's elaborate those details and state the full
rule in one go, upfront, and then state a separate guarantee that
matching an array against a slice pattern does not do a read.

We'll also fix a typo, add rule identifiers, and tighten up the
examples.

Author: traviscross

src/types/closure.md

@@ -365,38 +365,42 @@ let _ = &mut x; // ERROR: Cannot borrow `x` as mutable.
 c();
 ```
 
-r[type.closure.capture.precision.discriminants.slice-patterns]
-Matching against a [slice pattern][patterns.slice] that needs to inspect the length of the scrutinee performs a read of the pointer value in order to fetch the length. The read will cause the closure to borrow the relevant place by `ImmBorrow`.
+r[type.closure.capture.precision.discriminants.slice-patterns-slices]
+Matching a slice against a [slice pattern][patterns.slice] other than one with only a single [rest pattern][patterns.rest] (i.e. `[..]`) is treated as a read of the length from the slice and captures the slice by `ImmBorrow`.
 
-```rust,compile_fail,E0506
-let x: &mut [i32] = &mut [1, 2, 3];
-let c = || match x { // captures `*x` by ImmBorrow
-    [_, _, _] => println!("three elements"),
-    _ => println!("something else"),
+```rust,compile_fail,E0502
+let x: &mut [u8] = &mut [];
+let c = || match x { // Captures `*x` by `ImmBorrow`.
+    &mut [] => (),
+//       ^^
+// This matches a slice of exactly zero elements. To know whether the
+// scrutinee matches, the length must be read, causing the slice to
+// be captured.
+    _ => (),
 };
-x[0] += 1; // ERROR: cannot assign to `x[_]` because it is borrowed
+let _ = &mut *x; // ERROR: Cannot borrow `*x` as mutable.
 c();
 ```
 
-As such, matching against an array doesn't itself cause any borrows, as the lengthh is fixed and the pattern doesn't need to inspect it.
-
-```rust
-let mut x: [i32; 3] = [1, 2, 3];
-let c = || match x { // does not capture `x`
-    [_, _, _] => println!("three elements, obviously"),
+```rust,no_run
+let x: &mut [u8] = &mut [];
+let c = || match x { // Does not capture `*x`.
+    [..] => (),
+//   ^^ Rest pattern.
 };
-x[0] += 1; // `x` can be modified while the closure is live
+let _ = &mut *x; // OK: `*x` can be borrow here.
 c();
 ```
 
-Likewise, a slice pattern that matches slices of all possible lengths does not constitute a read.
+r[type.closure.capture.precision.discriminants.slice-patterns-arrays]
+As the length of an array is fixed by its type, matching an array against a slice pattern does not by itself capture the place.
 
-```rust
-let x: &mut [i32] = &mut [1, 2, 3];
-let c = || match x { // does not capture `x`
-    [..] => println!("always matches"),
+```rust,no_run
+let x: [u8; 1] = [0];
+let c = || match x { // Does not capture `x`.
+    [_] => (), // Length is fixed.
 };
-x[0] += 1; // `x` can be modified while the closure is live
+x; // OK: `x` can be moved here.
 c();
 ```