refactor: ParseError can carry an exit code

Reinstated use of ParseError for all error paths so as to retain existing semantics.

chore: add test for decoding

Load environment variables as a resolver (alecthomas#480)

hooks: Recursively search embedded fields for methods (alecthomas#494)

* hooks: Recursively search embedded fields for methods

Follow up to alecthomas#493 and 840220c

Kong currently supports hooks on embedded fields of a parsed node,
but only at the first level of embedding:

```
type mainCmd struct {
    FooOptions
}

type FooOptions struct {
    BarOptions
}

func (f *FooOptions) BeforeApply() error {
    // this will be called
}

type BarOptions struct {
}

func (b *BarOptions) BeforeApply() error {
    // this will not be called
}
```

This change adds support for hooks to be defined
on embedded fields of embedded fields so that the above
example would work as expected.

Per alecthomas#493, the definition of "embedded" field is adjusted to mean:

- Any anonymous (Go-embedded) field that is exported
- Any non-anonymous field that is tagged with `embed:""`

*Testing*:
Includes a test case for embedding an anonymous field in an `embed:""`
and an `embed:""` field in an anonymous field.

* Use recursion to build up the list of receivers

The 'receivers' parameter helps avoid constant memory allocation
as the backing storage for the slice is reused across recursive calls.

fix(Context.Run): Don't panic on unselected root node (alecthomas#484)

feat: add support for `Provide*() (<type>, error)` methods on commands

fix: regression where all args became passthrough

Fixes alecthomas#475

feat: add old "passthrough" behaviour back in as an option

`passthrough:""` or `passthrough:"all"` (the default) will pass through
all further arguments including unrecognised flags.

`passthrough:"partial"` will validate flags up until the `--` or the
first positional argument, then pass through all subsequent flags and
arguments.

fix: NPE due to checking if error is nil when it can be a value

Fixes alecthomas#468

feat: support recursive injection of provider parameters

This allows provider functions to accept parameters that are injected by other
bindings or binding providers, eg. call the provider function with the root CLI
struct (which is automatically bound by Kong):

  kong.BindToProvider(func(cli *CLI) (*Injected, error) { ... })