1. in parser we need.. type unification?
2. or perhaps just need to introduce type variables.

3. we can't resolve type for a recursive pair of functions until we've seen both of them..
   tho we could require letrec

def foo = lambda (n : i64) { let (n == 0) then 1 else n * foo(n - 1); };

strategy:
----------

while parsing def, instead of creating DefineExpr with nullptr TypeDescr:
a. create DefineExpr with TypeVariable.
(We have to do this because can't tell nullptr's apart,..)

- generalize xo::reflect::TypeDescrBase

// compose these into Expressions.
//
struct type_ref {
  bool is_concrete() const { return td_ && td_->is_concrete(); }

  // generated name, so we can map between types.  Don't want to create TypeDescr
  // every time we have a typed location. there'd be a lot of them, and hard to collect
  flatstring<11> id_;
  // if TypeDescr is concrete (fully described), this describes it
  TypeDescr td_;
};

// what we know about a type
//
struct TypeBlueprint : public Refcounted {
  static bool equal(bp<TypeTemplate> lhs, bp<TypeTemplate> rhs);

  type_ref ref_;

  // additional descriptive info...
};

// effectively these are constraints?
//
using TypeSubstitutionMap = map<string, rp<TypeTemplate>>;

will have typeunifier in parserstatemachine

struct TypeUnifier {
   // extend as unification proceeds
   //
   TypeSubstitutionMap substitutions_;
};

alt strategy
-------------