Effem is now Kapreolo and lives in another repo

pretty print Base IR

flatten the Base IR

Application of data oriented design.

Pros of flattening trees:
- Better cache locality.
- Smaller references (u32 vs Box (= usize often= u64))
- Cheaper allocation. Instead of individual `Box`es each requiring a
  heap alloc, just push to the same arena `Vec` (which only rarely
  allocates).
- Possibilities for easy deduplication (e.g. via a
  `HashMap<Stm, StmRef>`)
- Nodes are in topological order (I think?). This might be
  exploitable.

tweak base IR to separate divergence from operations more clearly

partly for prepping for flat tree in base

get rid of the nested defs as localid -> globaldef thing in abase

`Cache::fetch_evaluated_at` couldn't make sense of the `Operand::Local`s
it was getting. And there was no great reason to keep them nested
quite like that. Easier to just generate anonymous globals at the top
level.

We'll still need to keep track of which defs are downstream from which
though, for when we add support for rerunning with the same cache but
modified inputs. We'll need to know which defs to invalidate etc.
That's what the new `children` field in the glob defs. Just a set of
dowstream defs.

fix args not evaluated before app

fix infinite recursion on recursive def

add more binops & overload binops for all numeric types

add integers

fix parse::alt2 continuing with next alternative when it shouldn't

Add & fix test for using modules in code. Resolve own. to lib.fm

This now works

src/lib.fm:
  (def double (of (Fun [F64] F64) (fun [x] (* x 2.0))))

src/main.fm
  (def main (double.own. 21.0))

eval main.main.own. => 42

pretty errors

Had some consequences in Loc:s being added to ASTs.
Also, caching of modules & files was affected a bit.

basic bidirectional typing (infer / check)

abase & eval lambdas (not capturing closures yet though)

add blocks & other functionality to base

parse & resolve `fun`s

resolve unrooted names (defs in same module & prelude (+, *))

rework names & ids a bit, and start doing a little real resolving

also a bunch of other misc changes & fixes.
haven't been checking into vc for a bit

add readme

remove ints (for now)

Unnecessary complexity this early on. Just more cases to handle. More
inertia when I want to change stuff. We'll add them back when the
language actually starts getting more feature rich and we need them again.