Retrying errors during chunked-encoded body reading is not supported

In case of headers being correctly received if an error occurs during response body read (when chunked transfer-encoding is enabled) retries are completely ignored even in case of `stream=False` argument passed.

## Expected Result

Requests library supports specifying `stream=False` argument in methods so I would expect the library to apply retries if request fails in any scenario. I believe that content being loaded after the initial urllib3 request is being made should be considered an implementation detail and this logic should be handled by high-level `request` method.

## Actual Result

Currently retries are applied only during first urllib3 level request with `preload_content=False`. If an error occurs during body read an exception wrapper is passed to user.

In case of following example the stack trace is:

<details>
<summary>
Stack trace
</summary>

```
Traceback (most recent call last):
  File ".../python3.9/site-packages/urllib3/response.py", line 439, in _error_catcher
    yield
  File ".../python3.9/site-packages/urllib3/response.py", line 767, in read_chunked
    self._update_chunk_length()
  File ".../python/toloka_client/venv/lib/python3.9/site-packages/urllib3/response.py", line 697, in _update_chunk_length
    line = self._fp.fp.readline()
  File "/usr/local/Cellar/python@3.9/3.9.6/Frameworks/Python.framework/Versions/3.9/lib/python3.9/socket.py", line 704, in readinto
    return self._sock.recv_into(b)
socket.timeout: timed out

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File ".../python3.9/site-packages/requests/models.py", line 758, in generate
    for chunk in self.raw.stream(chunk_size, decode_content=True):
  File ".../python3.9/site-packages/urllib3/response.py", line 573, in stream
    for line in self.read_chunked(amt, decode_content=decode_content):
  File ".../python3.9/site-packages/urllib3/response.py", line 796, in read_chunked
    self._original_response.close()
  File "/usr/local/Cellar/python@3.9/3.9.6/Frameworks/Python.framework/Versions/3.9/lib/python3.9/contextlib.py", line 135, in __exit__
    self.gen.throw(type, value, traceback)
  File ".../python3.9/site-packages/urllib3/response.py", line 444, in _error_catcher
    raise ReadTimeoutError(self._pool, None, "Read timed out.")
urllib3.exceptions.ReadTimeoutError: HTTPConnectionPool(host='localhost', port=62510): Read timed out.

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "scratch.py", line 98, in <module>
    main()
  File "scratch.py", line 93, in main
    print(session.get(f'{url}/response', timeout=0.1).text, stream=False)
  File ".../python3.9/site-packages/requests/sessions.py", line 555, in get
    return self.request('GET', url, **kwargs)
  File ".../python3.9/site-packages/requests/sessions.py", line 542, in request
    resp = self.send(prep, **send_kwargs)
  File ".../python3.9/site-packages/requests/sessions.py", line 697, in send
    r.content
  File ".../python3.9/site-packages/requests/models.py", line 836, in content
    self._content = b''.join(self.iter_content(CONTENT_CHUNK_SIZE)) or b''
  File ".../python3.9/site-packages/requests/models.py", line 765, in generate
    raise ConnectionError(e)
requests.exceptions.ConnectionError: HTTPConnectionPool(host='localhost', port=62510): Read timed out.
```

</details>

## Reproduction Steps

Here is an example with local server implemented using aiohttp. In this case aiohttp server can be replaced with any other server that supports chunked encoding without changing the final behaviour (I used aiohttp for implementation just because it is easy to implement chunked-encoding transfer using this library).

```python
import asyncio
import time
import requests

from requests.adapters import HTTPAdapter
from urllib3.util import Retry
from aiohttp import web
from aiohttp.test_utils import unused_port
from multiprocessing import Process
from functools import wraps


class RetryCountingHandler:
    def __init__(self, retries_before_response):
        self.retries_left = retries_before_response

    async def get_response(self, request):
        response = web.StreamResponse()
        response.enable_chunked_encoding()
        await response.prepare(request)
        self.retries_left -= 1
        if self.retries_left >= 0:
            await asyncio.sleep(10)
        await response.write('Hello world'.encode('utf-8'))
        return response

    async def get_retries_left(self, request):
        return web.Response(text=str(self.retries_left))

    async def ping(self, request):
        return web.Response(text='OK')


def run_server(url, port):
    app = web.Application()
    handler = RetryCountingHandler(retries_before_response=10)
    app.add_routes([
        web.get('/response', handler.get_response),
        web.get('/retries_left', handler.get_retries_left),
        web.get('/ping', handler.ping)
    ])
    web.run_app(app, host=url, port=port)


def main():
    port = unused_port()
    url = f'http://localhost:{port}'

    server_process = Process(target=run_server, args=('localhost', port))
    server_process.daemon = True
    server_process.start()

    for _ in range(30):
        try:
            if requests.get(f'{url}/ping', timeout=0.1).status_code == 200:
                break
        except requests.exceptions.ConnectionError:
            pass

        print('Server is not started... sleeping for 1s')
        time.sleep(1)
    else:
        raise RuntimeError("Can't start server")


    adapter = HTTPAdapter(max_retries=Retry(11, backoff_factor=0))
    session = requests.Session()
    session.mount(url, adapter)
    print(session.get(f'{url}/response', timeout=0.1).text, stream=False)



if __name__ == "__main__":
    main()
```

## System Information

    $ python -m requests.help

```
{
  "chardet": {
    "version": "4.0.0"
  },
  "charset_normalizer": {
    "version": "2.0.2"
  },
  "cryptography": {
    "version": ""
  },
  "idna": {
    "version": "3.2"
  },
  "implementation": {
    "name": "CPython",
    "version": "3.9.6"
  },
  "platform": {
    "release": "19.6.0",
    "system": "Darwin"
  },
  "pyOpenSSL": {
    "openssl_version": "",
    "version": null
  },
  "requests": {
    "version": "2.26.0"
  },
  "system_ssl": {
    "version": "101010bf"
  },
  "urllib3": {
    "version": "1.26.6"
  },
  "using_charset_normalizer": false,
  "using_pyopenssl": false
}
```

Currently this issue can be fixed be writing custom `HTTPAdapter`:
```
class PreloadingHTTPAdapter(HTTPAdapter):
    @staticmethod
    def _override_preload_content(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            kwargs['preload_content'] = True
            kwargs['decode_content'] = True
            resp = func(*args, **kwargs)
            return resp

        return wrapper

    def build_response(self, req, resp):
        response = super().build_response(req, resp)
        if resp._body:
            response._content = resp.data
        return response

    def get_connection(self, *args, **kwargs):
        connection = super().get_connection(*args, **kwargs)
        connection.urlopen = self._override_preload_content(connection.urlopen)
        return connection
```

but I believe that it is an extremely hacky solution and it is very vulnerable to changing implementation details of both urllib3 and requests libraries.



I haven't double-checked, but I'm fairly certain we do not promise the behaviour you are expecting. Given that we're under a feature freeze, this would be a net-new feature and would not be implemented. (Also we've never supported this particular case.)

Because I had trouble understanding your circuitous statements, I'm going to also simplify what I think you're saying for myself and others.

1. You've sent a request and received the headers of the response. This means that the first `read` has completed and urllib3's retry logic no longer applies (that only applies to errors from the first `read()` call).
2. After receiving that, a read error occurs and you expect Requests to resend your initial request and try again without telling you. This is especially problematic because you've configured 11 total retries, some of which may have been used and we have no way of determining how many retries urllib3 used, so now we have to guess(?) how many are left in order to perform behaviour we've never promised