Fix read_line panic on non-empty buffer

[notgull]

The behavior of the canonical read_line is to append to whatever buffer
is passed into it. At the moment it assumes the buffer is empty and
panics otherwise. This commit adds a check for the buffer being empty,
and appends the string otherwise. This is very inefficient but should be
relatively uncommon.

This commit also adds a unit test to prevent regressions.

Fixes #124

[fogti]

This currently allocates twice in case that !buf.is_empty(), but that should be relatively easy to avoid:

• If buf.is_empty(), basically do the same as currently
• If !buf.is_empty(), check the string via core::str:from_utf8 instead, and when that is successful, append it to buf. It would be possible to also do that for buf.is_empty(), and String::from_utf8 also does that internally, but doing that require usage of String::from_utf8_unchecked after the check, which we might want to avoid.
• One perhaps needs a bit of work to factor out the common error handling part (perhaps creating a new enum for that or using Result<Result<_,_>,_> could be of use)

It might be possible (but is way more complicated) to reduce memory allocations further (keep in mind that we are currently:

• copying data out of the buffer of an AsyncBufRead object (that buffer usually has fixed size),
• appending it to bytes (possibly allocating)
• moving or copying data to buf later

), but that would necessitate a refactoring of the API and different arguments, so is out of scope here (idk if there is already a proper type for "String with a possibly-invalid-UTF-8 unverified tail", backed by a single Vec<u8>).

Besides that, there is something that irritates me about the original code of read_line_internal, because it basically throws away the bytes already buffered when bytes doesn't contain valid UTF-8, which feels unexpected (we could at least append the part to buf that is valid UTF-8).