The current `hasProperty()` matcher can't deal with
Java Records, as they are not compatible with JavaBeans
specification.

In this change, `HasProperty` first tries to do
the original thing and then tries to find a method
of which name is equivalent to the given property name,
if there's no matching property.

So for example,
if the class has a getter method named `property()`,
`hasProperty()` would regard it as the class has
a property named `property`.

I hope this change might be properly and easily removed
when the time comes and Hamcrest starts to support Java 17.

There is a flaw in 8201577, which is that
the logic can't distinguish if the found method is a getter.
Let's put a simple additional rule:
The property must be a getter,
so it should return something.

After the debate of pr hamcrest#426,
We decided to move all the methods of `MethodUtil`
to `PropertyUtil`.
There was a confusion of understanding
the name of the class `PropertyUtil`.
First I thought it was kind of a technical name
indicating that `PropertyUtil` deals with
java beans property.
But actually it wasn't just a technical name.
`PropertyUtil` means a tool to find out some
properties in the target class.
So to say, it is like a `PropertyFindingUtil`.
We don't have to change the utility name
even if it finds some methods of the target class,
not properties of it,
as it does what it is meant to do.

and polished its javadoc.

The basic approach is as same as the `HasProperty`
in 8201577.
`hasProperty(propertyName, valueMatcher)` will
recognize properties in java record classes if:

1. There's a method of which name is same to the given property name
2. The found method returns something

If it doesn't meet condition 1, the property does not exist.
If it doesn't meet condition 2, the property is write-only.

To achieve this goal I needed a different approach
from 8201577.
`samePropertyValuesAs(expectedBean, ignoredProperties)`
will recognize properties in java record classes if:

* There's a read accessor method of which name is same to the given property name

A read accessor method is a method
which acts like a getter for a field.
To check if the method is a read accessor method,
the algorithm filters the following:

1. The name of it should be identical to the name of the field.
2. It should return something.
3. It should not have any method parameters.

In this manner, we can now assure that
the collected methods are getters.

## Reference

* https://docs.oracle.com/en/java/javase/14/language/records.html

The former implementation
`methodDescriptorsFor()` can be
replaced to the new method
`recordReadAccessorMethodDescriptorsFor()`.
This doesn't change current behavior
except one, the case for the non-readable property.
Actually, there can't be any non-readable property in
Java Records by its specification.