Refactor cmd/ application logic to pkg/

This commit will separate the application level logic for the 'show', 'delete',
'validate', and 'diff' commands from the Cobra logic in the cmd/ package.  The
application level logic will be placed in pkg/kubecfg/.

fix integration tests

The integration commit (#90) raced with another (#80) that changes the
`kubecfg` command line.  This commit adds the newly-required `-f` flag.

Add basic integration test framework

Fix README

Now the commands take either an env or a file, so let's at least fix the
README to make it work with files.

Implement `init`; bring synchronization primitives to spec

The ksonnet.next design doc specifies the core kubecfg verbs (i.e., the
ones listed above) to all have the form:

  kubecfg <verb> [<env-name>|-f <file-or-dir>]

That is to say, each of these should be able to take either an
environment name, or a `-f` flag with a list of files and directories to
apply `verb` on. In the case of the environment, we will apply `verb` to
every component in the `components/` directory.

This commit implements this behavior for all these verbs.

This commit will introduce the ability of the `metadata.Manager` to
report every file in the `components/` directory.

This is primarily useful when we invoke the Jsonnet VM, as it requires a
list of files to expand. (The `template.Expander` also handles YAML and
JSON.)

This commit will introduce the `template.Expander` abstraction, which is
meant to abstract over an invocation of the Jsonnet VM. Specifically, it
provides facilities for users to provide (e.g.) Jpaths, ext vars, and so
on.

The main justification for this change is:

* We need a common way for the `pkg` and `cmd` packages to interact with
  the Jsonnet VM.
* The `utils` package is already too much of a catch-all.
* It's easier to think about an invocation of the Jsonnet VM when we
  additionally encapsulate the parameters we pass to it on every
  invocation in kubecfg.

This commit will implement the first version of the `init` subcommand.
This subcommand initializes a ksonnet application, including generating
the default directory tree and generating the appropriate ksonnet-lib.

`metadata.ClusterSpec` represents a specification for an abstract
Kubernetes cluster. For example, `version:1.7.0` represents a Kubernetes
cluster running a build from 1.7.0. This specification is primarily used
to generate ksonnet-lib.

This struct exposes a method, `data` that will retrieve the OpenAPI JSON
that specifies the API for a Kubernetes cluster. Eventually, `data` will
be able to read a file, pull from a URL, pull from a live cluster, or
pull a specific version of the API from the official Kubernetes
repository.

This commit introduces the the last of these options.

`metadata.Init` is meant to initialize a ksonnet application, including
its directory structure and the initial versions of various metadata
files in the tree. But, this implementation is incomplete: currently
only the directory tree is initialized.

This commit will change init to generate ksonnet-lib as part of the
initialization process.

The ksonnet-lib codebase exposes a package, ksonnet-gen, which will
automatically generate the ksonnet library for a given OpenAPI
specification of the Kubernetes API.

This commit vendors only the source in the ksonnet-gen package (rather
than the entire repository) as a dependency in the kubecfg project.

The codegen routines for ksonnet-lib depend on some Go 1.8 features
(e.g., `sort.Slice`). Once we vendor the dependency, this will cause the
build to fail perpetually for Go 1.7.

This commit therefore drops support for 1.7, making 1.8 the line of
supportability. This decision was made together with @anguslees, in
slack PMs.

Noticed and then audited in the course of other work.

Currently contains basic "update" and "delete" tests.
More cases will be added in followup patches.

Add application metadata management facilities

Much of the tooling build around ksonnet applications will be powered by
metadata presented in a structured directory format. This is similar in
principle to how Hugo and Rails structure web applications.

This commit will begin the process of introducing a FS-based state
machine that manages this directory structure. Primarily, this involves
introducing:

1. Init routines for the directory structure
2. Routines to search parent directories for a ksonnet application
   (similar to how git does this with repositories)

Initially, the directory structures looks like this:

  app-name/
    .ksonnet/   Metadata for ksonnet
    components/ Top-level Kubernetes objects defining application
    lib/        User-written .libsonnet files
    vendor/     Mixin libraries, prototypes

The `.ksonnet` file marks the application root, making it possible to
search parent directories for the root.

As time continues, more verbs will be introduced to manipulate this
metadata (including, e.g., vendoring dependencies, searching prototypes,
and so on).

Despite being seemingly the most popular mockable FS library, Afero does
not tag releases in git, and does not appear to have cut a release in
about a year. Hence, the following considerations were taken into
account when we vendored the dependency:

* The commits since the last release (2015) appear to be almost entirely
  bug fixes.
* In the case that we are calling to the OS's FS (rather than, say, a
  testable, memory-mapped FS), the Afero is a simple wrapper, and hence
  introduces little risk into the CLI tool. We verified this by looking
  at the actual source.
* We opened issue #129 to attempt to nudge the committers into using
  stable software engineering practices (e.g., tagging your releases),
  and we will see how this issue evolves.

Implement `validate` subcommand

Fetches schema from server without caching to disk.  Caching / offline
operation will be added in a followup PR.

Add CONTRIBUTING doc

Move code around and other cleanups

This will make it possible to inject fake dependencies, once the fake
dynamic client makes it into a client-go release.

(other commands will be moved similarly in future PRs)

- Move fqname to utils
- Add ResourceNameFor and use it to get a lowercased/pluralised
  version of the resource name

Implement garbage collection

Report client-go version in `version` subcommand

Make kubecfg diff exit with non-zero code when a diff is found.

Fixes #15