Remove JDK reflection hacks in favor of `Unsafe`

[sciwhiz12]

This PR fixes Artifactural's compatibility with Java 16 due to reflection into JDK internals, by replacing that reflection with the use of sun.misc.Unsafe.

Currently, Artifactural has a hack to modify final fields of classes by reflecting into Field.modifiers. This has two disadvantages:

• Requires maintenace of separately compiled code for the hack: one for Java 8 compatibility, and one for Java 9+ compatibility.
• Java 16's strong encapsulation of modules by default causes this reflection into the JDK's java.base/java.lang.reflect module to fail, without the proper arguments supplied to the JVM.

Because ForgeGradle 5 is planned to exclusively run on Java 16+, an alternative solution had to be found to this. Originally, I attempted to recreate the Gradle objects and substituting our own custom objects as needed, but this was discarded due to being open to the possibility of changes in Gradle's internals which would require that piece of code being fixed up over and over again to work on both old and newer versions of Gradle.

To avoid the JDK module reflection issue, this PR replaces that reflection with the use of sun.misc.Unsafe (accessed through the net.minecraftforge:unsafe project). To summarize, Unsafe allows Java programs to directly modify the JVM's memory, including being able to overwrite values of fields (even final fields) without triggering the module reflection checks.

This eliminates the issue of the JDK reflection preventing Java 16 compatibility (without user intervention), and also provides the opportunity to remove the separately compiled code for Java 8 and Java 9+.

The following changes are also done in this PR:

• Updating the Gradle wrapper to 6.9;
• Updating and cleaning up the buildscript to use latest plugin versions and use the new URL for the Forge Maven; and
• Updating the Jenkinsfile (based off of ForgeGradle's Jenkinsfile).

[LexManos]

Alright so this has been merged, sci was nice enough to do some testing using Unsafe on J16+ that makes it seem like it'll function even with their attempt to lock down reflection. At least the tests work for me. The next thing we need to do is bump this to Gradle 7+ so we get native J16 support. We don't have to worry about this change for G6.9, as that doesn't run on J16 it just can compile for it.

FG5 is targeting J16+ and G7 which is where we will use the 3.0 builds of this.