overhaul of proof format for new solver

This commit overhauls the proof format (in development) for the new core.

NOTE: this functionality is work in progress with a long way to go.
It is shielded by the sat.euf option, which is off by default and in pre-release state.
It is too early to fuzz or use it. It is pushed into master to shed light on road-map for certifying inferences of sat.euf.

It retires the ad-hoc extension of DRUP used by the SAT solver.
Instead it relies on SMT with ad-hoc extensions for proof terms.
It adds the following commands (consumed by proof_cmds.cpp):

- assume  - for input clauses
- learn   - when a clause is learned (or redundant clause is added)
- del     - when a clause is deleted.

The commands take a list of expressions of type Bool and the
last argument can optionally be of type Proof.
When the last argument is of type Proof it is provided as a hint
to justify the learned clause.

Proof hints can be checked using a self-contained proof
checker. The sat/smt/euf_proof_checker.h class provides
a plugin dispatcher for checkers.
It is instantiated with a checker for arithmetic lemmas,
so far for Farkas proofs.

Use example:
```
(set-option :sat.euf true)
(set-option :tactic.default_tactic smt)
(set-option :sat.smt.proof f.proof)
(declare-const x Int)
(declare-const y Int)
(declare-const z Int)
(declare-const u Int)
(assert (< x y))
(assert (< y z))
(assert (< z x))
(check-sat)
```

Run z3 on a file with above content.
Then run z3 on f.proof

```
(verified-smt)
(verified-smt)
(verified-smt)
(verified-farkas)
(verified-smt)
```

src/sat/smt/euf_proof_checker.cpp

@@ -0,0 +1,48 @@
+/*++
+Copyright (c) 2020 Microsoft Corporation
+
+Module Name:
+
+    euf_proof_checker.cpp
+
+Abstract:
+
+    Plugin manager for checking EUF proofs
+
+Author:
+
+    Nikolaj Bjorner (nbjorner) 2020-08-25
+
+--*/
+
+#include "ast/ast_pp.h"
+#include "sat/smt/euf_proof_checker.h"
+#include "sat/smt/arith_proof_checker.h"
+
+namespace euf {
+
+    proof_checker::proof_checker(ast_manager& m):
+        m(m) {
+        arith::proof_checker* apc = alloc(arith::proof_checker, m);
+        m_plugins.push_back(apc);
+        apc->register_plugins(*this);
+    }
+
+    proof_checker::~proof_checker() {}
+
+    void proof_checker::register_plugin(symbol const& rule, proof_checker_plugin* p) {
+        m_map.insert(rule, p);
+    }
+
+    bool proof_checker::check(expr_ref_vector const& clause, expr* e) {
+        if (!e || !is_app(e))
+            return false;
+        app* a = to_app(e);
+        proof_checker_plugin* p = nullptr;
+        if (m_map.find(a->get_decl()->get_name(), p)) 
+            return p->check(clause, a);
+        return false;
+    }
+
+}
+