This way type class inference is not invokved when used in tactics
like iPvs while not having to write an @.

(Idea suggested by Ralf.)

This way, it won't pick arbitrary (and possibly wrong!) inG instances
when multiple ones are available. We achieve this by declaring:

  Hint Mode inG - - +

So that type class inference only succeeds when the type of the ghost
variable does not include any evars.

This required me to make some minor changes throughout the whole
development making some types explicit.

This reverts commit c43eb936.

The hack using class_apply has some strange behaviors, see:

  https://sympa.inria.fr/sympa/arc/coq-club/2016-07/msg00094.html

We reify to a representation of expressions that includes an explicit
constructor for closed terms. Substitution can then be implemented as
the identify, which enables us to perform it using computation.

The intropattern {H} also meant clear (both in ssreflect, and the logic
part of the introduction pattern).

For example iIntros "{$H1 H2} H1" frames H1, clears H2, and introduces H1.

This fixes a bug in 916ff44a causing proof mode notations not being
pretty printed.

Concretely, when execution of any of the wp_ tactics does not yield
another wp, it will make sure that a view shift is kept. This
behavior was already partially there, but now it is hopefully more
consistent.

This tweak allows us to declare pvs as an instance of FromPure (it is not
an instance of IntoPure), making some tactics (like iPureIntro and done)
work with pvs too.

This is more natural, match should be used in user code, not case.

Fun test case to play arround with abstract predicates.

Fixes issue #20.

This introduces n hypotheses and destructs the nth one.

We used => before, which is strange, because it has another meaning
in ssreflect.

be the same as ↔️.

This is a fairly intrusive change, but at least makes notations more
consistent, and often shorter because fewer parentheses are needed. Note
that viewshifts already had the same precedence as →.

It used to be: (P ={E}=> Q) := (True ⊢ (P → |={E}=> Q))
Now it is: (P ={E}=> Q) := (P ⊢ |={E}=> Q)