revsetbenchmark: add `author(mpm) or author(lmoscovicz)` to the canonical list

This matters as `author(mpm)` have a lot of matches evenly split in the repo,
while `author(lmoscoviz)` have less match (and later). This changes the execution
path of the "or" operator a lot.
run-tests: create classes for representing tests

Currently, the state for an individual test is scattered across a number
of functions and variables. This patch begins a process of isolating a
single test's state into instances of a class. It does this by
establishing a new Test base class and child classes for Python tests
and T tests. The class currently has a run() API that proxies into the
existing "runner" functions. Upcoming patches will move the logic for
each test type into the class.
run-tests: move testtmp into Test class

This patch starts the process of moving test-specific variables into the
Test class. The ultimate goal is to be able to instantiate a Test with
minimal arguments and to call run() on it without too much thinking.
This will make it much easier to run tests from other contexts. It will
also enable things like running a test multiple times.
run-tests: move replacements generation into Test

The API is a bit funky. Things will look better once all state is
captured in Test.
run-tests: move createenv() into Test

createenv() is consulting lots of test-specific variables. It makes
sense to attach it to the Test class.
run-tests: move createhgrc() call into Test.run()

createhgrc() is an implementation detail of how tests are run. It makes
sense to move it into Test.run().

Note that this will cause the test execution time to include the
creation of hgrc. The author does not believe this is a significant
change worth worrying about.
run-tests: move replacements and port management into Test

replacements and ports are really implementation details of a Test. They
have been moved to instance variables.
run-tests: move killdaemons into Test.run()

killdaemons() was the only part of runone() looking at env variables. We
move killdaemons() into Test.run() to enable us to fully move env into
Test.
run-tests: move env into Test

Environment variables are an implementation detail of how tests are
executed. This patch moves environment variable logic into Test and
completely hides it from the outside.

With this patch, a Test can be executed with two lines: init + run().
Tests are still single-use and take a more arguments to the constructor
than likely necessary. These will get addressed in subsequent patches.
run-tests: clean up temp directory variables

testtmp is an implementation detail. It didn't need to be exposed to the
world.

threadtmp is derived from count. It is now created as part of the
constructor and mostly hidden from the outside world.
run-tests: capture execution results in a TestResult class

Some implementation details of test execution still live outside of
Test. These include determining what a result means and cleaning up
after the test.

To move to the world where more of this logic can live inside Test or a
derived object, the logic for test execution needs to be refactored.
Specifically, exception trapping and opportunities for result processing
need to be moved into Test.

This patch starts the process by establishing a TestResult class for
holding the results of a test execution. In order to actually use this
class, exception trapping and execution time recording needed to be
moved into Test.run().
run-tests: pass TestResult into run()
run-tests: give TestResult a skipped attribute
run-tests: capture reference output in TestResult class
run-tests: allow Test.run() to run multiple times

Test.run() can now be executed multiple times on the same Test instance.
This feature is currently unused and there are no plans to implement it.
The main reason for this work was to refactor testtmp, replacements, and
env to be run-time specific as opposed to Test instance specific.
run-tests: remove threadtmp in Test.cleanup()

threadtmp is an implementation detail. We move the cleanup of this
directory to Test.cleanup() and make the variable internal. The
cleanup function will eventually disappear into unittest machinery.
run-tests: roll pytest() into PythonTest._run()

Python was the old runner function. It no longer needs to exist since
the PythonTest class took its job.
run-tests: move t test parsing into its own function

Test parsing is somewhat complicated. This patch extracts it into its
own function.

The impetus of this patch is folding tsttest() into the TTest class.
Subsequent patches will continue this work until tsttest() no longer
exists.
run-tests: move t test execution from tsttest() to TTest.run()

After this patch, tsttest() only contains output/result processing.
run-tests: finish moving tsttest() into TTest