* allow closing async generators that are already closed
https://bugs.python.org/issue39606

* Prevent double awaiting of async iterator
https://bugs.python.org/issue39386

* Fix ag_running; prohibit running athrow/asend/aclose in parallel
https://bugs.python.org/issue30773

* Fix asynchronous generators to handle GeneratorExit in athrow()
https://bugs.python.org/issue33786

* Ignore GeneratorExit in async_gen_athrow_throw
https://bugs.python.org/issue35409

* make async_generator_athrow object tolerant to throwing exceptions
https://bugs.python.org/issue38013

Relaxed some of the checks of fused functions to be consistent with general CyFunctions.

```
 # cython: binding=True
def f(arg):
  pass

class C:  # or cdef class...
  f = f
  def g(self, ...):
    pass

C.f(something) or C().f() # doesn't enforce any checks on the type of arg -
 # with a fused function it does.

C.g(something) # assumes that self is "C" (at least for a cdef class)
 # but doesn't check it. A fused function enforces that it is C.

C.f() # fails with a fused function claiming too few arguments, even though
 # default arguments may make it a valid call
```

Obviously removing checks does make things a little less safe, but it
is consistent with the more general function behaviour. (I'm doing
this as part of a broad plan to abuse fused functions to be a bit
cleverer about decorators, but I don't think the motivation hugely
matters for this change)

Optimized inplace operations for str/unicode so that they're
genuinely done in place if no-one else needs the object. This
is what CPython tries to do (and string concatenation was
a point where it significantly beat Cython at times).

This only works if the types are known at compile time, so with
unknown types CPython will still be faster in some cases.

Note: Uses slightly odd-macro trickery - does modify the input argument too
(although only in places where it shouldn't matter).

Fix branch prediction hints for plain (unlikely/exceptional) "raise" statements in if/else clauses that are not preceded by other statements.

* Rewrote signature matching for fused cpdef function dispatch to use a pre-built tree index in a mutable default argument and be O(n).

* Added test to ensure proper differentiation between ambiguously compatible and definitely compatible arguments.

* Added test to ensure fused cpdef's can be called by the module itself during import.

* Added test to ensure consistent handling of ambiguous fused cpdef signatures.

* Test for explicitly defined fused cpdef method.

* Add .komodoproject to .gitignore.

* Add /cython_debug/ to .gitignore.

Closes #1385.

Disable a saved compiler option in the test runner that cannot currently be changed in the tests directly (only in external compiler runs).

Closes https://github.com/cython/cython/issues/3419

These were previously getting missed. Added code to specialize them and tests to prove it.

Fixes https://github.com/cython/cython/issues/3142

Also fixes https://github.com/cython/cython/issues/3460 - (seems related enough to go in the same PR)

Closes https://github.com/cython/cython/issues/3419

The comments are taken from the C API documentation
(https://docs.python.org/3.8/c-api/marshal.html).

This removes the `setup_requires` reference that AIUI is deprecated, in
favour of the `pyproject.toml` file which is what is supposedly needed nowadays.

The following code:
```
# cython: infer_types=True
import cython

@cython.cclass
class Foo:
    a: cython.double
    b: cython.double
    c: cython.double

    def __init__(self, a: cython.double, b: cython.double ,c: cython.double):
        self.a = a
        self.b = b
        self.c = c

def bar():
    l = []
    l.append(Foo(10, 20, 30))

    v = cython.declare(Foo, l[0])
    r = v.a + v.b
    print( r )

    v2 = cython.cast(Foo, l[0]) #Faster - No __Pyx_TypeTest() call
    r = v2.b + v2.c
    print( r )

bar()
```
works fine when compiled and throws an exception when interpreted: `TypeError: __init__() missing 2 required positional arguments: 'b' and 'c'`

It could be fixed if we change implementations as shown in the patch.
Also, added more tests for the cases I'm trying to fix
NB: Removed execution of `test_declare(None)` to make sure that the new `none_declare()` test works instead. `test_declare(None)` doesn't throw exception in pure mode but does it in the native mode

Replacing `hasattr(t, '__call__')` to `callable(t)` in the master branch broke the implementation and the tests because the construction was used to detect typedefs. To fix that I got rid of this check completely and replaced it to exact checks which also simplified the code

Changed `declare` implementation when initializing arguments are not provided. Now it correctly works with typedefs of the user classes and also directly support arrays:
    ```
    >>> EmptyClassSyn = cython.typedef(EmptyClass)
    >>> cython.declare(EmptyClassSyn) is None
    True
    >>> cython.declare(cython.int[2]) is not None
    True
    ```
Added missed return statement to `index_type` which made the following assigment possible:
    ```
        a = cython.declare(cython.int[2])
        a[0] = 1
    ```