This is a convenience function for pulling the value of the token that
denotes a statement or section.

codx is a new subpackage of codf that contains utility functions. Like
everything else about codf, the API is currently unstable but unlikely
to change drastically.

This uses a Filterer to select children of a ParentNode and return
them. For example, to get all foo statements in a document root, you'd
use `Filter(doc, FilterStatements, FilterNamed("foo"))`. This is
a convenience for grabbing relevant elements of an AST in an order
that's convenient for iterating thorugh, rather than walking the whole
document all at once.

These are to get the start and end location of nodes without typing
x.Token().Start each time. They're just convenience functions.

These are utility functions I end up copy/pasting between projects, so
I might as well merge them into codx for convenience.

- args.go contains simple statement and section argument parsing
  functions. These will likely change a good deal over time as my ideas
  aobut how to handle that solidify.

- mapping.go contains MapFunc and NodeMapper, which are used to wrap an
  existing Walker with a mapping function.

- include.go contains the IncludeMapper, which implements general
  purpose `include FILE;` directives. A simple filesystem-based
  IncludeFunc is provided, but there's no requirement that an
  IncludeFunc is disk-only.

- expand.go provides variable-expansion mappings.

- Replace hardcoded cases in ParseArg with use of ExprValue (and Value
  for other cases). This functions similar to flag.Value, except
  there's no need for it to support fmt.Stringer.

- Fix *url.URL type case. Regardless of whether a token fit a URL,
  a *url.URL output would return an error due to it falling out of its
  conditional to the error return.

This is mainly for use with protobuf-ish things and code where
a concrete zero value has to be distinct from no value (nil).

This allows you to just pull a token out for further inspection if
ParseArg and an ExprValue isn't really appropriate.

These can be used to create first-matching or all-matching sets of
arguments. AllOf is often more useful for pulling both the location or
token of a node out at the same time as its value so that you can
produce an error message. OneOf is useful with **T values where it's
useful to use the first non-nil value.

Without these, we get expected-but-got errors that're missing
information.