Optimize initial `OptionSpan`

Every request in a `*Client` starts with something like:

```cc
google::cloud::internal::OptionsSpan span(std::move(options), options_);
```

The `options_` member variable never changes value. We should avoid the implicit copy from these options. If we can hold them as a `std::shared_ptr` then maybe `ImmutableOptions` can become a class that holds two `Options`, one by value (initialized via move) and a `std::shared_ptr<>` with the remaining values.

Something like:

```cc
class internal::OptionsImpl { // Similar to the Options class today
public:
template auto get() const { ... }
// has() and get() rolled into a single operation.
template std::pair find() const { ... }
};

class internal::ImmutableOptions {
public:
template auto get() const {
auto [has, value] = impl_.find();
if (has) return *value;
return fallback_.get();
}

// No set or unset member functions.

private:
OptionsImpl impl_;
std::shared_ptr fallback_;
};

class Options {

private:
OptionsImpl impl_;
};

```

Start by tracing how each *Client constructs OptionsSpan and how Options and ImmutableOptions currently store and retrieve values. Evaluate the proposed OptionsImpl and shared fallback design against the existing copy behavior; done means the initial options avoid the implicit copy while preserving option lookup semantics.

Written by the indexing model from the issue text.