Since 0.8.1 pyte does not support Python 2.x anymore so it makes sense
to upgrade one of its dev dependencies, pyperf.

Receive via environ the geometry of the screen to test with a
default of 24 lines by 80 columns.
Add this and the input file into Runner's metadata so it is preserved in
the log file (if any)

Implement three more benchmark scenarios for testing screen.display,
screen.reset and screen.resize.

For the standard 24x80 geometry, these methods have a negligible cost
however of larger geometries, they can be up to 100 times slower than
stream.feed so benchmarking them is important.

Changed how the metadata is stored so on each bench_func call we encode
which scenario are we testing, with which screen class and geometry.

A shell script to test all the captured input files and run them
under different terminal geometries (24x80, 240x800, 2400x8000, 24x8000
and 2400x80).

These settings aim to stress pyte with larger and larger screens (by a
10 factor on both dimensions and on each dimension separately).

The input files in the tests/captured must be loaded with ByteStream and
not Stream, otherwise the \r are lost and the benchmark results may not
reflect real scenarios.

The former `for x in range(...)` implementation iterated over the all
the possibly indexes (for columns and lines) wasting cyclies because
some of those indexes (and in some cases most) pointed to non-existing
entries.

These non-existing entries were faked and a default character was
returned in place.

This commit instead makes display to iterate over the existing entries.
When gaps between to entries are detected, the gap is filled with the
same default character without having to pay for indexing non-entries.

Note: I found that in the current implementation of screen,
screen.buffer may have entries (chars in a line) outside of the width of
the screen. At the display method those are filtered out however I'm not
sure if this is not a real bug that was uncovered because never we
iterated over the data entries. If this is true, we may be wasting space
as we keep in memory chars that are outside of the screen.

Python generators (yield) and function calls are slower then normal
for-loops. Improve screen.display by x1 to x1.8 times faster by
inlining the code.

The assert that checks the width of each char is removed from
screen.display and put it into the tests. This ensures that our test
suite maintains the same quality and at the same time we make
screen.display ~x1.7 faster.

Instead of computing it on each screen.display, compute the width of the
char once on screen.draw and store it in the Char tuple.

This makes screen.display ~x1.10 to ~x1.20 faster and it makes
stream.feed only ~x1.01 slower in the worst case. This negative impact
is due the change on screen.draw but measurements on my lab show
inconsistent results (stream.feed didn't show a consistent performance
regression and ~x1.01 slower was the worst value that I've got).