Adopts the `SystemPropertyExtension`[1] from JUnit Pioneer into JUnit
Jupiter. While this is a faithful port some notable changes have been
made. With that in mind the API status has been set to experimental.

### `@RestoreSystemProperties` uses `Properties::clone`

When using `@RestoreSystemProperties` JUnit Pioneer would create a copy
of the effective properties in the object. This would include any
defaults as if they were regular values. I.e:

```java
static Properties createEffectiveClone(Properties original) {
	Properties clone = new Properties();

	// This implementation is used because:
	// System.getProperties() returns the actual Properties object, not a copy.
	// Clone doesn't include nested defaults, but propertyNames() does.
	original.propertyNames().asIterator().forEachRemaining(k -> {
		String v = original.getProperty(k.toString());

		if (v != null) {
			// v will be null if the actual value was an object
			clone.put(k, original.getProperty(k.toString()));
		}
	});

	return clone;
}
```

 JUnit instead uses `Properties::clone` and performs a best effort
 attempt to detect default properties and fail if any were detected. For
 classes that extend `Properties` it is assumed that `clone` is
 implemented with sufficient fidelity. I.e:

```java
static Properties cloneWithoutDefaults(ExtensionContext context, Properties properties) {
	// Custom implementations have to implement clone correctly.
	if (properties.getClass() == Properties.class) {
		throwIfHasObservableDefaults(context, properties);
	}
	return (Properties) properties.clone();
}
```

We do this because:

1. System properties are to the best of our knowledge created without
defaults. Nor are we aware of a good usecase for defaults. If you do
have a use case for this, please do create  a new issue to explain it.
2. Using `Properties::clone` provides a contract that is easier to
document and understand. It also allows subclasses of `Properties` to be
provided to tests. For example, a variant that does include defaults
when cloned.

### Restore "compromised"  entries

While strongly discouraged non-string values can be added to a
properties object.  The Pioneer implementation would not restore these
"compromised" values. This has been fixed in the JUnit implementation.

Closes: junit-team#4726

1. https://github.com/junit-pioneer/junit-pioneer/blob/062ce51296dab909119fd6c9f090b9d6a2982530/src/main/java/org/junitpioneer/jupiter/SystemPropertyExtension.java

Signed-off-by: mehulimukherjee <mehulimukherjee2017@gmail.com>