`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.

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

Add manifestJson and manifestYaml functions

jsonnet's `std.toString()` returns "compact" JSON.  Sometimes this is
not appropriate, particularly when generating large output that might
need to be viewed/debugged by a human.

This change implements manifestYaml and manifestJson functions, which
generate YAML and "pretty" JSON respectively.

A slight implementation wrinkle is that libjsonnet currently only
supports passing primitive (scalar) types to native functions, so
these arguments need to be JSON-serialised/unserialised across the
native function call boundary.

Set appropriate delete option for server version

Annoyingly, delete options `OrphanDependents` and `PropagationPolicy`
are mutually exclusive.  This change compares the k8s server version
to see if the server is going to look for the newer PropagationPolicy.

Fixes a78be141 (aka PR #59)

Update to client-go v3.0.0

Set delete propagation policy (to "foreground")

Kubernetes 1.6 adds a `PpropagationPolicy` to the delete options,
obsoleting the previous `OrphanDependents` boolean.

This change sets `PropagationPolicy=foreground`, keeping the legacy
`OrphanDependents=false` for older k8s servers.

Note that PropagationPolicy=background is broken in k8s 1.6 and (eg)
leaks pods from a deployment.  See kubernetes/kubernetes#44046 for
upstream discussion.

Add 'subset' diff stategy option that checks the live state is a subset of the config state.

Anonymously import the GCP auth provider to get the registration side effect.

Register *all* auth plugins (gcp + oidc)

Fix deploy runtime version check harder