Unchanged function added and all obj have `__eq__` method

See issue #2942. 

There are at least 3 reasons that one might write a test that looks like `assert foo(a) == foo(a)`:

1) to test that the `eval` routine is working for the object -- sometimes there are special cases that shouldn't be changed and such a test is trying to say "foo(a) should still be foo(a) after evaluation." The problem with writing a test like that, however, is that it will always pass, even if foo(a) changed.To handle such tests, a function named `unchanged` has been added that allows one to assert that the function and arguments used to build the object remain unchanged, e.g. `foo(0).func is foo and foo(0).args == (0,)`.
2) to show that something no longer fails. In this case one doesn't care what the output is, only that it doesn't fail. The `unchanged` function will ignore tests that have an inline after them. This encourages users to tell why an apparently do-nothing test is being added: `assert foo(0) == foo(0)  # doesn't fail` will not raise an error during code quality checks.
3) to test the `__eq__` method of the object. By writing `assert foo == foo  # __eq__ check` the test will not be flagged.

Any unannotated foo==foo test will be flagged as a code quality error since it is not clear which of the 3 cases such a test was written for.

Another test that has been added to the code quality checks is one to see that every object has an `__eq__` method.