cfg: inline from back to front

Intuitively, it makes sense to inline back to front:

* Suppose we are able to inline line i into line i+1. After that inline
  operation, we may now be able to inline line i-1 into line i+1. So we
  should check that next. This implies we should move backward in the
  program rather than moving forward.

* Will we lose anything by moving backward? Well, suppose we were able
  to inline line i into line i+1. Could that possibly have impacted the
  ability to inline line i+1 into line i+2? No. Thus, it is not possible
  that going backwards results in more passes over the program than
  going forward.

The only trick to implementation was that when sliding the window
forward, we need to remember line i+1 in the case of a successful
inline.

This is anecdotal, but for the attached chained.myl example, the time to
produce the logical plan was reduced for me from .58 seconds to .26.
compute_liveness: expand deepcopy

Seems to be much faster -- even without the prior commit, reduced
runtime for the previous example from .58s to about .30s. So while the
previous commit makes this function almost never called, it is still
much faster.
algebra.inline_operator: use the original op once

In many cases, we are inlining an operator into a statement that only
uses it once. We can save expensive deepcopy by reusing it. We only need
to copy if we use the operator twice.
scheme: remove unused code
expression.util: helper function to tell if expr has non-unnamed refs
rules,algebra: reduce unnecessary use of op.scheme()

Because op.scheme() is computed on demand, it is very expensive. Add
some utility functions in algebra to avoid computing the scheme in cases
where we do not need it.

In the sample case, this speeds up the query parsing/optimization time
dramatically. Which is nice for the UI.
scheme: remove one more unused function
rules: remove some unused imports
SplitSelects: potentially elide scheme computation
PushSelects, RemoveUnusedColumns: elide schemes where possible
interpreter: fix bug in get_json()
cli_test: test more of the CLI options
clang_myrial_tests: create intermediate outputs in the c_test_environment_directory
raco: cache schemes used in list comprehensions
Merge branch 'master' into cfg-speedup

Conflicts:
	raco/algebra.py
rules: another scheme() inside list comprehension
expression: add utility function to ensure unnamed refs

And use it in rules/algebra. Also add some comments.
cfg: add comment
rules: more helper use
cfg: comment apply_chaining