Directory reorg: move code into redo/, generate binaries in bin/.

It's time to start preparing for a version of redo that doesn't work
unless we build it first (because it will rely on C modules, and
eventually be rewritten in C altogether).

To get rolling, remove the old-style symlinks to the main programs, and
rename those programs from redo-*.py to redo/cmd_*.py.  We'll also move
all library functions into the redo/ dir, which is a more python-style
naming convention.

Previously, install.do was generating wrappers for installing in
/usr/bin, which extend sys.path and then import+run the right file.
This made "installed" redo work quite differently from running redo
inside its source tree.  Instead, let's always generate the wrappers in
bin/, and not make anything executable except those wrappers.

Since we're generating wrappers anyway, let's actually auto-detect the
right version of python for the running system; distros can't seem to
agree on what to call their python2 binaries (sigh). We'll fill in the
right #! shebang lines.  Since we're doing that, we can stop using
/usr/bin/env, which will a) make things slightly faster, and b) let us
use "python -S", which tells python not to load a bunch of extra crap
we're not using, thus improving startup times.

Annoyingly, we now have to build redo using minimal/do, then run the
tests using bin/redo.  To make this less annoying, we add a toplevel
./do script that knows the right steps, and a Makefile (whee!) for
people who are used to typing 'make' and 'make test' and 'make clean'.

redo-unlocked.py

@@ -1,41 +0,0 @@
-#!/usr/bin/env python2
-import sys, os
-import state
-from logs import err
-
-
-def main():
-    if len(sys.argv[1:]) < 2:
-        err('%s: at least 2 arguments expected.\n' % sys.argv[0])
-        sys.exit(1)
-
-    target = sys.argv[1]
-    deps = sys.argv[2:]
-
-    for d in deps:
-        assert d != target
-
-    me = state.File(name=target)
-
-    # Build the known dependencies of our primary target.  This *does* require
-    # grabbing locks.
-    os.environ['REDO_NO_OOB'] = '1'
-    argv = ['redo-ifchange'] + deps
-    rv = os.spawnvp(os.P_WAIT, argv[0], argv)
-    if rv:
-        sys.exit(rv)
-
-    # We know our caller already owns the lock on target, so we don't have to
-    # acquire another one; tell redo-ifchange about that.  Also, REDO_NO_OOB
-    # persists from up above, because we don't want to do OOB now either.
-    # (Actually it's most important for the primary target, since it's the one
-    # who initiated the OOB in the first place.)
-    os.environ['REDO_UNLOCKED'] = '1'
-    argv = ['redo-ifchange', target]
-    rv = os.spawnvp(os.P_WAIT, argv[0], argv)
-    if rv:
-        sys.exit(rv)
-
-
-if __name__ == '__main__':
-    main()