make everything an expression in Magnolisp

i.e., everything that was a statement previously

this makes prototyping easier as do not need both expr and stat versions
of many constructs in the language

this also allows any of the previously supported `let` forms in
expression context (since now everything is)

this change introduces a unit type named `Void`, and a corresponding
`VoidStat` expression into the IR

this change also makes LetLocalEc and AppLocalEc be core language,
replacing the less powerful BlockExpr and Return; the new core language
is still only for escapes, and does not enable jumping in, which would
enable looping as well

additionally, this change introduces a fix to copy propagation to
account for jumps in the code

    map (values) in expr position to empty SeqExpr during parsing;
    such (values) expressions can be introduced by Racket into
    bindingless let-values contexts

    deal with unit-typed expressions in statement lifting

    introduce ast-rm-dead-constants pass to remove dead constant value
    expressions (i.e., their value is not used, and have no side
    effects)

    account for Goto nodes in copy propagation; jumps from Gotos
    introduce new possible value assignments at the target label, which
    are now considered

    add a pass to optimize and normalize LetLocalEc; replaces previous,
    more simplistic version that only dropped code from the end of
    sequences called 'ast-normalize-LetLocalEc'; removes dead code due
    to jumps; for conditionals, only if there is a jump out from both
    branches do we know for sure that some jump occurred, so
    `target-sum` to return #f in other cases

    support 'magnolisp-nothing stx prop; expressions flagged with this
    are like (begin) during expr parsing

    have continuation refs also be `Var` nodes (and remove `Label` node
    type), but add KontT type for continuations: since given to begin
    with, type inference does not attempt to infer these, and complain
    when it cannot

    adjust ast-splice-SeqExpr

    add ExprStat node type

    StatCont -> SeqCont

    remove BlockExpr and Return node types and their use

    Apply -> ApplyExpr

    CxxLabel* -> Label*

    CxxReturnOne -> ReturnStat

    change parser to not have parse-stat context
have it be `Bool` instead of `bool` (to match `Void` casing)
remove support for a just-dropped core syntactic form

this removes use and support of 'magnolisp-nothing stxprop;
just 'in-racket is sufficient at the moment
add an early pass to eliminate obviously dead code

to reduce the need to type annotate (dead) expressions
let `do` block value be produced by a fall-through value
update docs to reflect recent language changes
let/annotate -> let-annotate
allow multiple expressions in `function` body
add `begin0` expressions into supported core language
add a function for formatting with `clang-format`
add a test case runner that runs Magnolisp via C++

for now requires a fairly recent version of Clang
(actually for no particular reason) to actually test anything