Changing a-if to be ALettable, and changing the compilation of them

accordingly, so that we don't have to allocate lambda helpers for the
continuation after an if expression.

(cherry picked from commit 9bc36d18f73ac76c320dbb541576e5ff287a240b)

Conflicts:
	src/arr/compiler/concat-lists.arr

(cherry picked from commit 9731804c9baf704e86fbba064f5db0493a6235f6)

Conflicts:
	src/arr/compiler/anf-loop-compiler.arr
no more ast-split.  regresses some tests that check for contract errors on unsatisfied function-return annotations; those will be fixed in a later commit when I finish merging as many of these other commits as I can.

(cherry picked from commit d908959ce2d44ed8322b5b3afc3478769e3dfa90)
(cherry picked from commit 28641a3fa4f1e60dff5e27afc42a4c9ee8ec9b76)

Conflicts:
	src/arr/compiler/ast-split.arr
remove unused anf.arr forms

(cherry picked from commit 4ffe181b8666de01d5efb092e993436e1287346f)
(cherry picked from commit 7366a891718d73f060fb4a10ff6c198db7197c89)

Conflicts:
	src/arr/compiler/anf-loop-compiler.arr
eliminating dummy assignments to variables for sequencing

(cherry picked from commit 47263f2e1cb80e9b780d9764abd29bc61eee4b7a)
(cherry picked from commit 663b0028387ec27dc0ddbdec7d62fd1553059526)
wrong location used in the stack when reporting errors

(cherry picked from commit ca6e870787b9dd09737940e7abb4bebfc983790e)
(cherry picked from commit 8b7271f952cbad8123b9c2702109d66581987567)
missing import of Either library

(cherry picked from commit 67fe20594da74dd23e7c871fd9562fa9077f810d)
Merge branch 'master' of github.com:brownplt/pyret-lang
adding arity checking everywhere I can think of... also, because of arity checking, splitting "string-split" into string-split (which splits only once, at the first location of the splitter), and string-split-all (which splits everywhere the splitter string occurs)
This commit combines many of the changes from several commits in the no-helper-funs2 branch, that can't readily be disentangled:

- Includes fix from commit e01b5b69df64b1d5e92433e72a3082e8d2db40da, to check return annotations from functions whose last expression is an application or if or cases.

- Most of commit 87241d09a10416773a84a775b3a01d1dbc7b0b0c, which gives an alternate implementation of cases expressions.  It adds some fields for reflective access over data values, and starts to compile cases to simply be more switch branches.  This latter behavior is now present but not used (we still compile cases to use the _match methods).  The advantage to this method is better error locations for cases arity errors, but the disadvantage is horribly bloated stack frames with hundreds of local variables.  We'll keep the former but not the latter.

- Making pattern locations more precise in AST, for use in error messages (commit 29e31dbb435e932abe2156ed67b6c5e38390942a)

- Most of the infrastructure for distinguishing between singletons and nullary constructors in cases expressions (commit 15b6a77c2533912fb0f04f6e3535408fb82c841c).  Again, this is pending changing the compilation of cases again.

- minor changes (commit 1f59111cc323e0ed429e19e1fc244e64fe5c4705)

This commit introduces some new failing tests (for arity checking on cases branches) that need to be fixed in a subsequent commit.
Merge github.com:brownplt/pyret-lang
Fixing the compilation of cases expressions.  The new pattern is a hybrid of the old `_match` style and the newer switch-branches style.  We construct a dispatch object containing the label numbers to go to, for each variant of a data and set `$step` to that, just as in the no-helper-funs approach.  But instead of inlining the bodies of all the Pyret cases as switch-branches in the current function, we construct a JS closure for the current branch and invoke it, roughly as in the older `_match` approach.  Instead of compiling a `$fields` function that constructs an array of the fields and returns it, as in the no-helper-funs approach, we instead compile a `$app_fields` function that takes a callback and invokes it with the fields, just as in the desugared cases branches of the `_match` approach.  The advantage to the new hybrid style is that it avoids allocating closures for all the branches, as in the old approach, and avoids the bloated stack frames of the no-helper-funs approach.

Also changed:
-- added location fields to `a-lettable` and `a-val`, because I need to get the location of an AExpr and an ALettable at some points, and having one exception is really annoying.
-- restored the description strings to `safeCall` uses, for better stack printing
--  added a missing import of Either to the checker library
-- minor formatting changes
Test sharing and greatest lower bound for records.

There was a minor bug with processing shared fields in data types. There
is now a test to make sure that that code path is taken. Tests have also
been added to make sure that the greatest lower bound for records is
determined correctly.
Fixing #240.

More or less exhaustive testing that all combinations of tokens and whitespace result in tokens with precise position information.  (Some combinations are ignored, because e.g. "check:" + "=" == "check" + ":=", which leads to annoying exceptions to the generic testing loop.  Also, the three-token combinations are commented out for now, just because running so many millions of tests takes too long.)

Additionally, the position information in the default actions of ListCons and KeepOnly has been refined whenever there's at least 1 child.  (There's still a mild ambiguity as to what location to assign to a zero-width production: when such a production appears at the beginning of another rule, it would be good to use the start-position of the rest of the rule; when it appears at the end, it should use the end-position of the rest of the rule.  Since zero-width productions could nest arbitrarily deeply, this isn't easy to solve.  The heuristic being used is, since most zero-width rules in practice are starred or bracketed sub-rules and therefore inlined into their parent productions, if the parent rule is non-empty it will ignore the position of the zero-width child, otherwise it'll use the same potentially-bogus position as its zero-width child.  This may break the well-nesting of positions in the generated parse tree, but this shouldn't be a problem in practice since there are by definition no tokens in the zero-width rules...  I have some vague ideas for a more principled fix to this problem, but it's not worth doing right now.)

Finally, some tokens (CARET and PARENNOSPACE) were not properly trimmed of their surrounding whitespace, which led to overly broad locations.  Moreover, the tokens that end in colons should not have the same regex as normal alphabetic keywords.  And, the regex for describing whitespace after a token should be broadened to include the end of a string or an immediately adjacent comment-start character.  This makes more programs lex, and makes the exhaustive testing above much easier.

As a convenience and counterpart to just-parse,js, I've added just-lex.js, which spits out the token stream with position information.
Refactoring the checkImage and checkImageOrScene functions so that they avoid compiling the same closure over and over again, and reuse that closure to make working Image and Scene type predicates.  No tests yet, but this fixes #239.
Removing `s-bless` and `s-confirm`.  Fixes #233.
fix tests to import either
Merge branch 'master-hybrid'
some more deep recursive tests for annotations
new bootstrap with merged master-hybrid
Convert JS string to Pyret string in list-files().