This branch adds fields to the `OutboundPolicies` API messages for
configuring request timeouts. The `HttpRoute.Rule` and `GrpcRoute.Rule`
messages now contain a `requestTimeout` field, which contains a
`Duration` for a request timeout for that rule. In addition, the
`RouteBackend` messages also contain a `requestTimeout` field, which
configures a duration for requests dispatched to that specific backend.
All new fields have comments describing their intended semantics.

These fields are primarily intended to support the new timeout fields
added to the HTTPRoute CRD in GEP-1742 (see linkerd/linkerd2#10969). The
HTTPRoute timeout configuration are an additional field on the `rule`
fields in a route that contains optional `request` and `backendRequest`
timeouts. This means that a single request timeout and backend request
timeout is set for all backends on an individual route rule. 

The proxy API additions in this PR are somewhat more flexible than the
current HTTPRoute CRD, as each `RouteBackend` has its *own* field for
the `backendRequest` timeout. This means that in theory, independent
`backendRequest` timeout values could be configured for each individual
backend. HTTPRoute doesn't currently support this, but it felt like a
good idea to add this flexibility in the proxy API regardless, to
support future use cases.

PR #10969 adds support for the GEP-1742 `timeouts` field to the
HTTPRoute CRD. This branch implements actual support for these fields in
the policy controller. The timeout fields are now read and used to set
the timeout fields added to the proxy-api in
linkerd/linkerd2-proxy-api#243.

In addition, I've added code to ensure that the timeout fields are
parsed correctly when a JSON manifest is deserialized. The current
implementation represents timeouts in the bindings as a Rust
`std::time::Duration` type. `Duration` does implement
`serde::Deserialize` and `serde::Serialize`, but its serialization
implementation attempts to (de)serialize it as a struct consisting of a
number of seconds and a number of subsecond nanoseconds. The timeout
fields are instead supposed to be represented as strings in the Go
standard library's `time.ParseDuration` format. Therefore, I've added a
newtype which wraps the Rust `std::time::Duration` and implements the
same parsing logic as Go. Eventually, I'd like to upstream the
implementation of this to `kube-rs`; see kube-rs/kube#1222 for details.

Depends on #10969
Depends on linkerd/linkerd2-proxy-api#243

Signed-off-by: Eliza Weisman <[email protected]>