Delay resolving super classes until referenced

[jmao-denver]

Fixes #142

1. be able to generate Python types from Java classes with complicated cyclic references
2. fix a reference counting issue when a new Python type fails to finalize
3. fix the Python tests and disable the Java tests due to previous changes (years ago) to enable auto PyObjects cleanup in Java.
4. add a limited GH check workflow to run the Python tests on Linux
5. add two new Python test cases

[cpwright]

We should attempt to add a unit test for this. If we understand have a deep enough understanding of the underlying problem, I expect we could have simple fixture classes to demonstrate it.

[niloc132]

Worth noting that we don't run jpy tests at this time as part of CI or releases, they don't consistently pass enough to be useful. Deephaven-core has its own modified suite that we run instead.

[chipkent]

Does this need an error log?

[jmao-denver]

Probably not b/c the functions that resolves the members (methods, fields, etc.) log the specific errors. That said it wouldn't hurt to log it at this level.

[devinrsmith]

At first, I thought "resolve" was a proxy to java Class.forName "initialize" param, but that is not the case. "resolve" here is jpy-logic for "have I reflected over the class type so I can know all the methods I can call".

It is user accessible via jpy.get_type("SomeClass", resolve=...). We might want to add some tests around this:

AClass = jpy.get_type("AClass", resolve=False)
BClass = jpy.get_type("BClass", resolve=False) # extends AClass
CClass = jpy.get_type("CClass", resolve=False) # extends BClass

# tests to show the above classes are not resolved

jpy.get_type("BClass")

# tests to show that AClass and BClass are resolved; and CClass is still not resolved

jpy.get_type("CClass")

# tests to show that AClass, BClass, CClass are resolved

[devinrsmith]

I'm also noticing we may be overcounting in JType_InitComponentType and JType_InitSuperType:

    if (superClassRef != NULL) {
        type->superType = JType_GetType(jenv, superClassRef, resolve);
        if (type->superType == NULL) {
            return -1;
        }
        JPy_INCREF(type->superType);
        JPy_DELETE_LOCAL_REF(superClassRef);
    }

JType_GetType should be incrementing the ref count for us, so we shouldn't need to increment it again, right?

[devinrsmith]

Jianfeng and I went over this and improved the reference counting logic, which I think is more correct now. Practically speaking though, once a type is successfully resolved into the jpy type ref dict, there is no (official) way to remove it, so it should stay referenced forever.