starting the new module/rule architecture
rule
cache.py and some more junk

None of this runs yet, or even tries to run. Also adding *.pyc to
.gitignore. I think vim is compiling things...
cache is working
load_plugins is working
local module parse is working
parsing remote modules
building (no imports yet)
main.py
working imports
check for peru file before running
rename local_plugin to path_plugin
update test.sh to run the new code
delete the original peru script
change the default peru file name from "peru" to "peru.yaml"

This is less likely to cause weird file collisions, and it also makes it
easier for editors to turn on the right syntax highlighting by default.
cleaning up the plugin interface by passing a runtime
default rule is now just "rule"

We were using a field called "default_rule" to specify which rule
counted as the default for a module. That was pretty ugly, and it
bloated the hello-world example.

One option was to allow modules to include rule fields directly, the
idea being that these fields applied to the default rule of that module.
That was concise, but the problem is that we also want some module
fields (e.g. "imports") to apply to *all* rules within the module. So it
would be ambiguous which fields affected only the default rule.

The current compromise is to specify the default rule with just "rule:"
(instead of "rule foo:"). Fields within that rule clearly apply only to
that rule, the hello-world example is still reasonably concise, and we
avoid needing to bless a particular rule name as "the one that means
default".

    module hello_world_example:
        type: git
        url: http://example.com
        rev: master
        rule:
            build: make
            export: out/
make 'rev' an optional field for the git plugin
declare modules as "type module name"

The mantatory "type" field was clunky. Declaring a module as e.g.
"git module foo" is cleaner, and more natural to read. Now that "rev" is
an optional field, the hello world example with no explicit default rule
is very concise:

    git module hello_world_example:
        url: http://example.com

    imports:
        hello_world_example: local_folder/
allow imports to environment variables

Normally imports are given as paths where we should dump rule outputs.
Interpret a path beginning with '$' as an environment variable import.
The rule is still built (or fetched from cache), but the outputs are put
in a temp directory, and the given environment variable is set to the
path to that directory before any build commands are run.