Before they were not, for example:

  Check ('10 + '10 )%L.           (* prints ('10 + '10)%L *)
  Eval simpl in ('10 + '10 )%L.   (* prints (Lit 10 + Lit 10)%L *)

The notation added by this comment is ambigious, for example the
notation '10 + '10 is used for both:

  BinOp PlusOp (Lit (LitNat 10)) (Lit (LitNat 10))
  BinOp PlusOp (of_val (LitV (LitNat 10))) (of_val (LitV (LitNat 10)))

But fortunatelly, these terms are convertible.

Note that literals 'x are now parsed as values (as a LitV), but still
pretty printed when they appear as expressions (as a Lit).

Now notations are pretty printed in the same way as they are parsed.
Before "let x := e1 in e2" was notation for "(fun x => e2) e1",
resulting in overlapping notations for the same thing.

We can use a named representation because we only substitute closed values. This
idea is borrowed from Pierce's Software Foundations.

The named representation has the following advantages:
* Programs are much better readable than those using De Bruijn indexes.
* Substitutions on closed terms (where all variables are explicit strings) can
  be performed by a mere simpl instead of Autosubst's asimpl. The performance
  of simpl seems better than asimpl.
* Syntactic sugar refolds better.

add basic notions of literals, unary operators and binary operators, and use them to define +, -, <=, ...

Actual proofs will end up using own and inv, and none of the notions defined in ownership.v

We should not depend on unreleased, git-only versions.
This reverts commit ee948028.