Make Matrix equals and hashCode obey the Object contract

[alxkm]

Matrix violates the Object.equals/Object.hashCode contract in two ways, so an equal
Matrix is not found in a HashSet and cannot be used as a HashMap key. Variant and
DataValue carrying a Matrix inherit it, because Variant.valueHash() falls through to the
value's own hashCode() for anything that is not an array.

1. hashCode() hashes the array identity, not its contents

Objects.hash(flatArray, dataType) calls flatArray.hashCode(), and flatArray is declared
Object, so for a primitive or object array that is the identity hash:

Matrix m1 = new Matrix(new int[][] {{1, 2}, {3, 4}});
Matrix m2 = new Matrix(new int[][] {{1, 2}, {3, 4}});

m1.equals(m2);                    // true
m1.hashCode() == m2.hashCode();   // false
Set.of(m1).contains(m2);          // false

equals() boxes primitive arrays before comparing, so new Matrix(int[][]) and
new Matrix(Integer[][]) are equal (pinned by the existing primitiveBoxedEquality test) but
also hash differently today.

2. equals() shortcuts past dimensions and dataType

The thisArray == thatArray shortcut returns true before either is compared, while
hashCode() does account for both — the same contract violation from the other side:

int[] elements = {1, 2, 3, 4};

new Matrix(elements, new int[] {2, 2})
    .equals(new Matrix(elements, new int[] {4, 1}));              // true

new Matrix(elements, new int[] {2, 2}, OpcUaDataType.Int32)
    .equals(new Matrix(elements, new int[] {2, 2}, OpcUaDataType.UInt32));  // true

Matrix does not copy the elements it is given and getElements() hands the backing array out
directly, so a shared backing array is reachable through the public Matrix(Object, int[])
constructors.

The two are entangled: fixing only hashCode() leaves case 2 violating the contract, and fixing
only equals() leaves case 1. Neither half restores it on its own, so both are here.

Change

• Hash the elements by value, boxing primitive arrays first so a Matrix of primitives hashes the
  same as the equal Matrix of the boxed type, matching how equals() compares them.
  Arrays.deepHashCode(box(prim[])) equals Arrays.hashCode(prim[]) for all eight primitive
  types, so this is consistent in both directions.
• Include dataType in the hash alongside dimensions, both of which equals() compares.
• Compare dimensions and dataType up front in equals(), which also removes the duplicated
  comparison from its two branches.

No behaviour change for unequal matrices, and no in-tree caller relies on the old behaviour.

Tests

Four tests added to MatrixTest. All four fail before the change and pass after:

MatrixTest.equalMatricesHashTheSame                       expected: <679162395> but was: <-1506169415>
MatrixTest.primitiveBoxedHashEquality                     expected: <-1070723957> but was: <-1468407034>
MatrixTest.sharedElementsWithDifferentDimensionsAreNotEqual  expected: not equal but was: dimensions=[4, 1]
MatrixTest.sharedElementsWithDifferentDataTypesAreNotEqual   expected: not equal but was: dataType=UInt32

Verified on JDK 17 with mvn -pl opc-ua-sdk/integration-tests -am test: stack-core, transport,
sdk-core, sdk-client, dtd-core, dtd-reader, sdk-server, encoding-json, encoding-xml and the
integration tests all pass — 2283 tests, 0 failures, 0 errors. mvn -pl opc-ua-stack/stack-core verify passes, including spotless:check.

---

• You have signed an Eclipse Contributor Agreement and are committing using the same email address
• Your code contains any tests relevant to the problem you are solving
• All new and existing tests passed
• Code follows the style guidelines and Checkstyle passes