The case tactic is faster than destruct.

Example:

Goal
  ¬False → ¬False → ¬False → ¬False → ¬False → ¬False → ¬False →
  False.
Proof.
  intros. done. (* takes very long *)

Add locking to value-scope notation for lambdas

This attempts to hide all our locking machinery so that users don't have to care. To this end, `locked` is added to the value-scope notation for lambdas and recursive functions, and the tactics wp_rec and wp_lam are enhanced to unlock properly.

The main open question is: How can we figure out automatically what to unfold? The heuristic I cam up with fails in barrier_client because there, we have a value parameterized by something on the Coq level.

Maybe a more viable alternative would be to add locking to the coercion that embeds values into expressions?

Cc @robbertkrebbers @jjourdan

See merge request !34

This reverts commit b115ff3f.

Update a comment in cmra_big_op.v

fixes a small typo in the comments

See merge request !33

I added the old one in 176a588c but it was never used.

New definition of contractive.

The current notion of `Contractive` does not allow one to deal with functions with multiple arguments, for example, binary functions that are contractive in both arguments (like `lft_vs` in lambdarust), or binary functions that are contractive in one of their arguments.

To that end, I propose I reformulate the notion of `Contractive` so that we can express being contractive using a `Proper`. The new definition is:

    Definition dist_later {A : ofeT} (n : nat) (x y : A) : Prop :=
      match n with 0 => True | S n => x ≡{n}≡ y end.
    Notation Contractive f := (∀ n, Proper (dist_later n ==> dist n) f).

Also, it turns out that using this definition we can implement a `solve_contractive` tactic in the same way as the `solve_proper` tactic.

Unfortunately, the new tactic does not quite work for the weakest precondition connective in Iris because the proof involves induction, and the induction hypothesis does not quite fit into the new `solve_contractive` tactic.

See merge request !32

Using this new definition we can express being contractive using a
Proper. This has the following advantages:

- It makes it easier to state that a function with multiple arguments
  is contractive (in all or some arguments).
- A solve_contractive tactic can be implemented by extending the
  solve_proper tactic.