My first bit of nontrivial Rust. It was born out of my frustration with most
CI/CD systems and their massive overengineered-yet-still-somehow-missing-the-
point. The design goal was to simplify automatic, continuous builds in a
reliable, reproducable way.

It currently only does the barest bit of that, but it serves its purpose so
far. My server has a simple bash wrapper around this that reads names from a
socket and runs the build that matches it.

This code then reads the configuration and runs a command in as isolated of an
environment as possible. At the moment that just means clearing all environment
variables and running in a timestamped directory (but you'd be surprised how
uncommon that is). It archives the specified files and records stdout/err and
the exit code.

At the moment, this is pretty bare, and it's due several overhauls, one of
which should be relatively soon, as I've run into an issue with having
colons in the path. Which is to say it currently does and it really shouldn't.

Other soon-to-be-added features are:

* support for archiving folders
* pre/post/error commands
* streaming out stdout/err of the commands
* passing arguments to commands
* cancelling commands cleanly
* expanding variables in configuration files

Between all of those, I should have everything I need to build out a potential
UI (probably just a read-only live website) and tooling. There is no ETA on
that, I don't know if it will even ever happen, but it's a possibility that I'm
keeping in mind as I go.

After that I'll evaluate integrating what I've learned from my foray into
the contanerization APIs, but that's still a ways out (and also Linux-specific,
which I'm a bit hesitant to put into something so generic).

Along the way this is going to get rewritten a few times and updated to more
modern Rust (no doubt multiple times at the rate I've been going so far..).

Still, this is a pretty reliable workhorse for me, and it does what it needs
to quickly, stably, and efficiently.