~jojo/Carth

Release 0.3.1. Update CHANGELOG & bump version
Read env vars of lib path and module path at runtime

Before they were compiled into the `carth` binary, but to work with
Guix in the future, I feel it's better to allow the paths to be
changed arbitrarily by the user/system without recompilation.
Allow string literals as patterns
Let `undefined` in std panic instead of recurse forever
Add some conventient functions to construct lists of length 1 to 6

Note: very hardcoded and ugly, but will have to do for now.
Fix recursive type issue in List in std

The problem with the old def was that only the tail was boxed, so
there were still cases where mutual type recursion could happen
without indirection in the car of the list.

Example:
(type Syntax
  (SList (List Syntax))
  (SIdent Str))

Assuming constructor Cons of List, expanding one step:
(type Syntax
  (SList Syntax (Box (List Syntax))
         ^^^^^^ -- recursion here
  (SIdent Str))
Add Void type and void-elim func to core lib, mostly to demonstrate
Add core functions {mul,div}-int
Remove character literals. Less confusion for users, I think

There is no one correct definition of "character". Valid definitions
include: ASCII character, Unicode codepoint, Unicode grapheme
cluster.

UTF-32 codepoints make quite a bit of sense -- it's fixed width and
can represent almost all common "symbols", unlike ASCII which is very
US-centric. The problem is that some things that render as a single
glyph to the user are actually composed of multiple codepoints. These
are "grapheme clusters". For example, some emojis are actually
grapheme clusters rendered as a single glyph. The codepoints `brown
skin tone` and `smiling face` in sequence often render as a single,
brown-skinned smiling face.

Different existing languages handle characters in different ways as
well.

I think we'll just stick with strings for now, and not recognizing
that there's a single-correct "element" type of strings, so to
say. There should be functions to convert strings sequences of bytes, of
codepoints, and of grapheme clusters, but no single "iterate"
instance, for example.
Remove Algebraic Datatypes from TODO
Update TODO. Algebraic Datatypes are done!
Refactor desugaring, remove AnnotAst.{Fun,Match}
Update README: it's AGPLv3 *or later* & note about virality
Allow pattern matching on uninhabited types, which returns Absurd

The following is now legal:

```
(type Bottom)

(define: bottom-elimination
    (forall (a) (Fun Bottom a))
  (fun-match))
```
Don't use NonEmpty in Ast

Neither Let, Match, nor FunMatch must actually have >=1 elements...
Move decision tree compilation of pattern matches to separate pass

This is better because the types of the AST must be fully inferred
before doing this, so unless it happens in a separate pass after
inference and substitution, we have to do "inline" substitution, which
is hacky.
Minor fix in Makefile
Fix "typos" in CHANGELOG
Release 0.3.0. Update CHANGELOG & bump version
Change license from AGPLv3 to AGPLv3-or-later
Next