buzzy update

The `buzzy update` updates any repositories that are local copies of
some remote source.  (We don't have any repository types that are like
that, but we already have a way for repositories to provide an update
action, so any new remote repository types should seamlessly start to
work with this command once we write them.)
Refactor loading from a filesystem repository

This patchs moves all of the functions that actually load the contents
of a filesystem repository into the repo's load method.  (Before we were
performing some of the steps in the repo constructor.)  The loading
logic has also been moved into a separate helper function.  This means
that was used to be called a “filesystem” repo is now a “local
filesystem” repo — i.e., one where the repository directory is already
present on the local filesystem.  Repositories that are cloned from some
remote source will be completely separate repo implementations; they'll
just all happen to have a call to this helper function somewhere in
their `load` methods.
The great variable renaming

This patch changes the name of just about every environment variable.
I'm trying to be more consistent with how directories are named, and how
variables are nested into nice namespaces.  So now, all of the variables
that have to do with a repository start with `repo.`.  Variables for
identifying directories now always end in `_dir`, and variables
identifying files end in something specific to the type of file (e.g.,
`_yaml`).
Actions for cloning and updating git repos

This patch adds helper functions that create actions that clone or
update a remote git repository.
Update to latest libcork
Use libcork's free_user_data macro

Instead of our own.
Remove action type

Actions are a thing of the past.  Instead of having a separate type to
manage actions, we just do stuff directly.  An “action” is now just a
regular C function; when it returns, the action should have been
performed.  If it has prereqs, it should recursively call the functions
that perform the prereq.  If we should only perform the action once, it
should somehow keep track of whether it's been executed already.

The main thing we were using actions and action phases for were to keep
track of the number of actions that would eventually be run, so that we
could have a nice `[XX/YY]` prefix when we logged which actions were
being performed.  But it complicates things, especially since we're
going to have remote repositories, whose contents will be loaded in an
action.  If those remote repos have dependencies on other repos, we
won't know that until we've started the action that clones and loads its
contents.  That messes up counts anyway, so for now, we're going to
abandon the total action count, and go with the much simpler API.
Repository links

You can now put a `links.yaml` file into your repository directory, to
define repository dependencies.  This is usually used when your repo
contains a package that is defined in some other repository.  Linking
the two together ensures that the definition of the prereq package is
available before you start building anything.
Merge branch 'feature/links' into develop

* feature/links:
  Repository links
  Remove action type
  Use libcork's free_user_data macro
  Update to latest libcork
  Actions for cloning and updating git repos
  The great variable renaming
  Refactor loading from a filesystem repository
  buzzy update