Add Dockerfile

[Docker] is a implementation of Linux containers which offer many of the
same benefits as virtual machines, but are much more lightweight.  They
allow you to package up a program and it's dependencies such that it will
run exactly the same on any machine.  They can also provide isolatoion such
that the host machine is isolated from changes made in the container.

This is potentially very useful to stb-tester.  stb-tester can be difficult
to deploy due to the dependencies.  Docker offers a way to easily provide a
standardised stb-tester environment.  It is also useful in a CI context as,
much like Travis, you could run arbritary user code without risking the
host system.

A Dockerfile contains the instructions on how to create a container.
Containers start out with a base image and build on top of that.  In this
case the stb-tester container is based ubuntu 14.04 (LTS).  Any container
can be used as the base for other containers.  Our users can base their
containers on the stb-tester container if they wish.

Docker also provides an [index].  This is a global repository of docker
images.  Docker containers in the index are easier to deploy[^1] and use as
a base for other images.  It also provides a service called "[trusted
builds]" where your image will be built and published for you, from github,
with a guarantee that the sources there are the source of the container.
One constraint is that the Dockerfile must be in the root of the repo and
present at clone time.  This means that we can't generate it as a part of
the build process.

[^1]: You can just type `docker run stb-tester:latest` and you're up and
      running.
[Docker]: http://docker.io/
[index]: https://index.docker.io/
[trusted builds]: http://blog.docker.com/2013/11/introducing-trusted-builds/
Makefile: Add docker-build target

Creates a docker image from the current status in git.  This is useful if
you want a docker image of a development version of stb-tester, rather than
using one of the "[trusted builds]".

When building a Dockerfile docker keeps a cache of intermediate stages.  It
decides if it needs to re-run a command from the Dockerfile if the command
changes, or in the case of the ADD command, if the files that are being
added to the container change.  These changes include file metadata such as
mtime and atime.  I use `touch` here to normalise the timestamps of all the
files from the tarball to the UNIX epoch.  This avoids defeating docker's
caching so we don't have to download all the package dependencies every
time we type `make docker-build` as long as the list of dependencies don't
change.

[trusted builds]: http://blog.docker.com/2013/11/introducing-trusted-builds/