Enable privacy check for enum methods.
Fix incorrect non-exhaustive matching for fixed length vecs

Code like this is fixed now:

```
fn foo(p: [u8, ..4]) {
    match p {
        [a, b, c, d] => {}
    };
}
```

Invalid constructors are not reported as errors yet:

```
fn foo(p: [u8, ..4]) {
    match p {
        [_, _, _] => {} // this should be error
        [_, _, _, _, _, .._] => {} // and this
        _ => {}
    }
}
```

Issue #8311 is partially fixed by this commit. Fixed-length arrays in
let statement are not yet allowed:

```
let [a, b, c] = [1, 2, 3]; // still fails
```
rust-mode: make indentation customizable

Add new variable rust-indent-offset, defaulting to
the old value, and use it.
Add std::iterator::order with lexical ordering functions for sequences

Use Eq + Ord for lexicographical ordering of sequences.

For each of <, <=, >= or > as R, use::

    [x, ..xs] R [y, ..ys]  =  if x != y { x R y } else { xs R ys }

Previous code using `a < b` and then `!(b < a)` for short-circuiting
fails on cases such as  [1.0, 2.0] < [0.0/0.0, 3.0], where the first
element was effectively considered equal.
extra::dlist: Use iterator::order for sequence ordering
std: Implement traits for the one-tuple

(A,) did not have the trait implementations of 2- to 12- tuples.
std::vec: Use iterator::order functions for Eq, Ord, TotalOrd, TotalEq
std: Fix Ord for Option, using iterator::order
std: Fix tuple lexicographical order

Use the definition, where R is <, <=, >=, or >

    [x, ..xs] R [y, ..ys]  =  if x != y { x R y } else { xs R ys }

Previously, tuples would only implement < and derive the other
comparisons from it; this is incorrect. Included are several testcases
involving NaN comparisons that are now correct.

Previously, tuples would consider an element equal if both a < b and
b < a were false, this was also incorrect.
std::iterator::order test cases
std::vec: Fix typo in fn ne
typo in tutorial
Add #[inline] to impl Zero for ()

Follow-up to #8155
Allow attributes to appear as macro arguments

Fixes #8393
std::tuple: Use != properly in Eq::ne for tuples

Just like the Ord methods, Eq::ne needs to be implemented in terms of
the same operation on the elements.
Implement `lower_bound_iter`/`upper_bound_iter` for TrieMap/TrieSet
std: add a Clone impl for HashSet.
Add parse-error recovery for erroneous `struct_id { }` form.

There are 4 different new tests, to check some different scenarios for
what the parse context is at the time of recovery, becasue our
compile-fail infrastructure does not appear to handle verifying
error-recovery situations.

Differentiate between unit-like struct definition item and unit-like
struct construction in the error message.

----

More generally, outlines a more generic strategy for parse error
recovery: By committing to an expression/statement at set points in
the parser, we can then do some look-ahead to catch common mistakes
and skip over them.

One detail about this strategy is that you want to avoid emitting the
"helpful" message unless the input is reasonably close to the case of
interest.  (E.g. do not warn about a potential unit struct for an
input of the form `let hmm = do foo { } { };`)

To accomplish this, I added (partial) last_token tracking; used for
`commit_stmt` support.

The check_for_erroneous_unit_struct_expecting fn returns bool to
signal whether it "made progress"; currently unused; this is meant for
use to compose several such recovery checks together in a loop.
Switch to using .enumerate() some places in _match.
Fix vector pattern matching. Closes #6909.