Increase isFunctionCallExternal() precision by using InferType

[blitz-1306]

export function isFunctionCallExternal(call: FunctionCall, inference: InferType): boolean {
    if (call.kind !== FunctionCallKind.FunctionCall) {
        return false;
    }

    if (
        call.vFunctionCallType === ExternalReferenceType.Builtin &&
        CALL_BUILTINS.includes(call.vFunctionName)
    ) {
        return true;
    }

    const exprT = inference.typeOf(call.vExpression);

    return exprT instanceof FunctionType && exprT.visibility === FunctionVisibility.External;
}

Above implementation would be more precise than pending implementation from #159, as it does not rely on typeString lookups.

However, implementing it as in above example is blocked due to failures of unit test. The exprT is resolved to a following:

FunctionType {
  id: 141,
  src: undefined,
  name: undefined,
  parameters: [],
  returns: [],
  visibility: 'public',
  mutability: 'nonpayable',
  implicitFirstArg: false
}

Here is the related Solidity sample:

contract Main {
    function c() public {}
    function d() public {}

    function main() public payable {
        (true ? this.c : this.d)();
    }
}

This sample is a shortened version of sample in external_calls.spec.ts integration test. The reason of failure is that it would need more time and efforts to investigate how to handle such expressions in typing context to figure out that the member access result is an external function (that is somehow done by compiler and reflected in typeString).

Current implementation seem to be fragile in edge-cases if we have struct with word external somewhere in the name, if also refered as an argument.