The old syntax:   abstract expr [spec]...

The semicolon binds more loosely than "abstract" and
the specification clauses are optional, so that
"abstract e1; e2" is the same as "(abstract e1); e2"
and "abstract e1; e2; ensures {...}" is a syntax error.

The new syntax:   abstract [spec]... expr end

This allows to put sequences of expressions under "abstract"
without ambiguity and moves the specification clauses to the
beginning. In other words, "abstract" becomes a "begin" with
a specification attached. The spec-at-the-top is consistent
with the syntax of functions and the whole seems to be more
natural for the intented use of "abstract" (a logical cut).

Examples:

  begin ... expr; end

  let fn x y = ... expr ; in ...

  match ... with pat -> ... expr ; | pat -> ... expr ; end

In this way, it's much easier to add and remove additional
assertions at the end of ()-typed blocks.

(used to be in Permut libraries)
new library array.ArrayPermut2, similar to ArrayPermut, but using
number of occurrences

Comment out the lemmas about symmetry of permutation:
they perturb our provers and are of little interest in
the case of successive array permutations.

If the record update { expr with f1 = ...; f2 = ... } updates
each field in the record, the intermediate variable for expr
is unused. Avoid the warning by naming this variable "_q ".

It should be noted that 2ff8efca disables the "forgotten diverges"
warning for Eabstr, which changes the behaviour, but is a good idea
anyway.

as follows:

maps:   permut_sub     -> permut
arrays: map_permut_sub -> permut     (to be consistent with maps)
        permut_sub     -> permut_sub
        permut         -> permut_all