Since the namespace must be specified in the parsed manifest for us to retrieve
it, we don't need to set this flag. Kubectl figures it out on its own.

These values are never actually used. They look like they are, but their only
usage is immediately reassigned.

This change to the interface facilitates creating an Applier that combines all
yamels into a multidoc to be applied in one call to kubectl.

Note that the deleted test was testing behaviour that exists nowhere in flux.
All references to `SyncAction` in the code contain only a single change, so the
test was unnecessary.

Since the namespace flag is no longer needed for kubectl, and since the tests
don't actually need the object name, we can pass a byte slice and simplify a
bit.

This change guides us towards doing the single mega-apply without smushing bytes
into an apiObject in a kludgey way.

As much as I love finding places to put channels, in this case it is entirely
unnecessary. The only use of actionc can be replaced with a mutex, and any
future methods can just compete for the lock instead of competing for a channel
write.

This brings back the previous ordering without doing a sort. Since we no longer
apply objects one at a time, we don't need an id.

This command was simply testing the mock.

We have this enormous block of nothingness all for satisying the requirements of
a constructor we don't even need to use.

In some not-so-well-defined cases, applying an object to the default namespace
can fail when its yaml doesn't explicitly specify the namespace. The simplest
way to overcome this is to separate them out and pass the namespace flag to
kubectl.

The ordering of application/deletion of namespaces before/after namespaced
resources is specific to kubernetes and so does not belong in the generic sync
package. This ordering is now implicitly handled by the order in which commands
are run in the kubernetes package.

It occurred to me that there's no good reason this state should be stored within
the struct that happens to implement the Applier interface. The state can be
built in the Sync method and then garbage collected at the end.