text: Title: BaseUrl: Provide a property or method to access the encoded URL string.
  Body: ### Initial Checks
  
  - [x] I have searched Google & GitHub for similar requests and couldn't find anything
  - [x] I have read and followed [the docs](https://docs.pydantic.dev) and still think this feature is missing
  
  ### Description
  
  This feature request is the result of hitting a bug in our application and wishing there was a way to prevent it in the future.
  
  ## Context
  
  Through the body of this feature request, I use `HttpUrl` as an example, but this feature request likely applies to the whole _BaseUrl hierarchy and possibly other unrelated but similar types.
  
  Imagine a BaseModel looking something like the following:
  ```python
  class MyData(BaseModel):
    my_url: HttpUrl | None
  ```
  
  And an API like the following:
  ```python
  def store_my_url(my_url: str | None) -> None: ...
  ```
  
  The important part is that the API of `store_my_url` is very inflexible, and it aggressively checks the type of its input.
  
  The bug we had was with code like the following: `store_my_url(str(my_data.my_url))` (where `my_data: MyData`). Unfortunately, this is almost right, but no tooling(1) will help you identify that you are going to convert `None` into `"None"` which is entirely unintended.
  
  (1) The way we have mypy configured doesn't seem to catch this, and I think we have it on a super strict mode.
  
  ## Feature Request / Proposal
  
  It would be nice if there was a property or method like:
  ```python
  @property
  def encoded(self) -> str:  # This needs a better name.
    return str(self)
  ```
  
  This would allow the buggy call to be written as: `store_my_url(my_data.my_url.encoded)` which would have instantly failed type checking and avoided the translation error. This would also make changing the `my_url` field of MyData from `HttpUrl` to `HttpUrl | None` safer as static analysis tooling would be able to identify more places where the type union would need to be updated.
  
  Alternative approaches to solving this problem would also be acceptable as I might have overlooked something. It would be nice if the pattern for converting `HttpUrl | None` to a string representation could be less error prone.
  
  Thanks for your consideration.
  
  ### Affected Components
  
  - [ ] [Compatibility between releases](https://docs.pydantic.dev/changelog/)
  - [ ] [Data validation/parsing](https://docs.pydantic.dev/concepts/models/#basic-model-usage)
  - [ ] [Data serialization](https://docs.pydantic.dev/concepts/serialization/) - `.model_dump()` and `.model_dump_json()`
  - [ ] [JSON Schema](https://docs.pydantic.dev/concepts/json_schema/)
  - [ ] [Dataclasses](https://docs.pydantic.dev/concepts/dataclasses/)
  - [ ] [Model Config](https://docs.pydantic.dev/concepts/config/)
  - [x] [Field Types](https://docs.pydantic.dev/api/types/) - adding or changing a particular data type
  - [ ] [Function validation decorator](https://docs.pydantic.dev/concepts/validation_decorator/)
  - [ ] [Generic Models](https://docs.pydantic.dev/concepts/models/#generic-models)
  - [ ] [Other Model behaviour](https://docs.pydantic.dev/concepts/models/) - `model_construct()`, pickling, private attributes, ORM mode
  - [ ] [Plugins](https://docs.pydantic.dev/) and integration with other tools - mypy, FastAPI, python-devtools, Hypothesis, VS Code, PyCharm, etc.