This PR implements Iterators.Reverse iteration for the EachLine iterator, so that now e.g. last(eachline(io)) will work. (This seems to have been requested multiple times on discourse etcetera, and is nontrivial for users implement efficiently themselves. It also seems to be a pretty common question in Python, where the most common answers involve reading the whole file to get the last few lines., or executing an external tail program.)

For seekable streams, it works by reading the data from the end in 4kiB chunks. Performance seems comparable to forwards iteration.

For non-seekable streams, it falls back to reading the whole stream into memory. However, for last(eachline(...)) and take(Reverse(eachline(...)), n) it uses an algorithm (similar to how the Unix tail function works) that requires only bounded memory — it reads the file in a sequence of 4kiB chunks, but discards earlier chunks if they are not needed for the requested number of lines. it throws an exception when seekend or seek is called.

I noticed that first(r::Reverse) was calling last(r.itr), which fails for non-indexable iterators because last(itr) defaults to itr[end], so I changed it to use the default implementation (in abstractarrays.jl) which iterates once. Otherwise, you can't implement last(itr::MyType) by first(Iterators.Reverse(itr)). This is analogous to how last(itr, n) is already implemented. (It might be good to change the default last(itr) method, but that's a topic for another PR.)