implement type inference

Two things out of one mechanism. `_' as a type means "work it out from
the initializer", so (var n _ (strlen s)) stops needing size-t spelled
out; `type-of' hands a macro the type of an expression, so a macro can
dispatch on what it was handed rather than on what was declared. Both
read the same answers from two sides.

Algorithm W's core, intra-procedural, with the extensions C forces:

  - an unknown type, since (include stdio.h) brings in names we never
    parsed. Unification is consistency rather than equality, so
    anything touching an unparsed declaration stops constraining
    instead of rejecting a program that compiled yesterday;
  - the usual arithmetic conversions, since `+' is not a function of
    one type;
  - checking mode for initializers, since #(0 0) has no type of its own
    and takes one from its context. #(T : ...) is the way out of that.

What it wanted on the way:

  - what type a *name* has, which neither the typedef nor the tag
    database recorded. One table serves functions and variables, since
    a function type already has a surface spelling;
  - a scope chain, so a (var c int 9) inside a do ends with the block;
  - form-type, keyed by cons cell, so one form has one type;
  - macros expanded during the walk rather than before it, so type-of
    is answered in the scope the macro was written in.

Closures take the same machinery: a receiver whose type comes from a
call, captures written (name expr) and typed from the expression, and
conversion from a bare function wherever a closure is expected.

type-match grew `_' on the pattern side, since (closure ((int)) int)
and (closure ((float)) int) were separate clauses for one case.

tests/sex-programs/fixpoint.sex

@@ -1,7 +1,8 @@
 (input)
 (output "direct: 120"
         "fac: 120 3628800"
-        "fib: 55 6765")
+        "fib: 55 6765"
+        "applied on the spot: 120")
 (return 0)
 
 ;;; A fixed point built out of closures, which is the hardest thing to
@@ -52,4 +53,9 @@
   (var fib (closure ((int)) int) (fix (& fib-knot)))
   (printf "fac: %d %d\n" (fac 5) (fac 10))
   (printf "fib: %d %d\n" (fib 10) (fib 20))
+
+  ;; the combinator's result invoked where it is returned, with no
+  ;; intervening `var' -- the receiver's type is the return type of the
+  ;; signature it came from, which is what the name table records
+  (printf "applied on the spot: %d\n" ((fix (& fac-knot)) 5))
   (return 0))