Add an `optional` flag to `Option.auto` to flag options that do not have defaults as optional

[richardhathaway-8451]

Add an optional (or required, if thinking about it as an inverse) flag to the Option.auto method to allow a user to mark options with no default value as optional.

For example:

@Option.namespace
class FOO:
    A: str


@dataset(dispatch = FOO.A)
def my_dataset():
    return 'default'

@my_dataset.overload(alias = 'overload')
def my_dataset_overload():
    return 'overload'

In this example, FOO.A should be optional, because if a user doesn't provide this option, the default implementation is used. However, doing FOO.validate({}) will fail because validate expects to see FOO.A in the options.

A syntax such as A: str = Option.auto(optional = True) could fix the situation.

[richardhathaway-8451]

This simple situation makes sense, however, this does open up additional questions, that may not be as easy to answer:

1. There could be a situation where there is a set of 3 options, and while none of the options by itself is required, 1 of the 3 MUST be set by the user. This could arise through the use of Coalesce. A possible way of solving this could be:

@Option.namespace
class FOO:
    @Option.namespace(<provide some args here indicating that 1 of the 3 is required>)
    class BAR:
          A: str
          B: str
          C: str

2. There could also be a situation where an option is required for a little-used part of a package. It would be useful if there were a way to only raise an error when validating the namespace only if that part of the package is being used.
   For this second issue, this is likely very difficult to implement, and developers should simply organize packages in logical ways, provide defaults whenever possible, and perhaps prompt users to validate sub-namespaces individually rather than an overarching namespace.

[richardhathaway-8451]

There may be other situations that come up I haven't thought of, so thinking that some care should be taken when crafting a solution.

[austinwarner-8451]

Yeah, I think that might open up a can of worms pretty quickly. My gut instinct is to only allow options in the namespace to be optional or required, and then any more complex validation logic should probably live in the validate method of the downstream Evaluatable objects. So rather than relying on NAMESPACE.validate to catch the edge cases, just use Coalesce.validate to check if at least one is provided.