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'.

paths.py

@@ -1,49 +0,0 @@
-import os
-import vars
-from logs import debug2
-
-
-def _default_do_files(filename):
-    l = filename.split('.')
-    for i in range(1, len(l)+1):
-        basename = '.'.join(l[:i])
-        ext = '.'.join(l[i:])
-        if ext:
-            ext = '.' + ext
-        yield ("default%s.do" % ext), basename, ext
-
-
-def possible_do_files(t):
-    dirname, filename = os.path.split(t)
-    yield (os.path.join(vars.BASE, dirname), "%s.do" % filename,
-           '', filename, '')
-
-    # It's important to try every possibility in a directory before resorting
-    # to a parent directory.  Think about nested projects: We don't want
-    # ../../default.o.do to take precedence over ../default.do, because
-    # the former one might just be an artifact of someone embedding my project
-    # into theirs as a subdir.  When they do, my rules should still be used
-    # for building my project in *all* cases.
-    t = os.path.normpath(os.path.join(vars.BASE, t))
-    dirname, filename = os.path.split(t)
-    dirbits = dirname.split('/')
-    # since t is an absolute path, dirbits[0] is always '', so we don't
-    # need to count all the way down to i=0.
-    for i in range(len(dirbits), 0, -1):
-        basedir = '/'.join(dirbits[:i])
-        subdir = '/'.join(dirbits[i:])
-        for dofile, basename, ext in _default_do_files(filename):
-            yield (basedir, dofile,
-                   subdir, os.path.join(subdir, basename), ext)
-
-
-def find_do_file(f):
-    for dodir, dofile, basedir, basename, ext in possible_do_files(f.name):
-        dopath = os.path.join(dodir, dofile)
-        debug2('%s: %s:%s ?\n' % (f.name, dodir, dofile))
-        if os.path.exists(dopath):
-            f.add_dep('m', dopath)
-            return dodir, dofile, basedir, basename, ext
-        else:
-            f.add_dep('c', dopath)
-    return None, None, None, None, None