Python: Improve modelling of overloaded methods

[tausbn]

The @typing.overload decorator allows the user to specify precise types for polymorphic functions. Unfortunately, our call graph does not account for this, which means methods such as findFunctionAccordingToMro will happily return all of the resolved methods with the specified name -- even the ones that don't do anything.

This is a problem for queries that check that the correct arguments are being passed. Given

import typing

class OverloadedInit:
    @typing.overload
    def __init__(self, x: int) -> None: ...

    @typing.overload
    def __init__(self, x: str, y: str) -> None: ...

    def __init__(self, x, y=None):
        pass

it looks like the first __init__ expects a single argument, and the second expects two, when in fact it can accept either (because in the method that actually gets called, y has a default value).

To get around this, we add a new predicate hasOverloadDecorator which checks (syntactically, because it's used in the call graph computation) whether a function is likely to be overloaded. We then use that predicate to filter out resolved methods where the target is a typing overload.

To test this, I added a new test separate from the usual call graph tests, primarily because we need to know not only that some call is resolved properly, but also what target it is resolved to.