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/paths.py

@@ -0,0 +1,49 @@
+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