Remove wall-time / unused skip tick protection (#11412)

Spigot still maintains some partial implementation of "tick skipping", a
practice in which the MinecraftServer.currentTick field is updated not
by an increment of one per actual tick, but instead set to
System.currentTimeMillis() / 50. This behaviour means that the tracked
tick may "skip" a tick value in case a previous tick took more than the
expected 50ms.

To compensate for this in important paths, spigot/craftbukkit
implements "wall-time". Instead of incrementing/decrementing ticks on
block entities/entities by one for each call to their tick() method,
they instead increment/decrement important values, like
an ItemEntity's age or pickupDelay, by the difference of
`currentTick - lastTick`, where `lastTick` is the value of
`currentTick` during the last tick() call.

These "fixes" however do not play nicely with minecraft's simulation
distance as entities/block entities implementing the above behaviour
would "catch up" their values when moving from a non-ticking chunk to a
ticking one as their `lastTick` value remains stuck on the last tick in
a ticking chunk and hence lead to a large "catch up" once ticked again.

Paper completely removes the "tick skipping" behaviour (See patch
"Further-improve-server-tick-loop"), making the above precautions
completely unnecessary, which also rids paper of the previous described
incompatibility with non-ticking chunks.

patches/server/0444-Optimize-Dynamic-get-Missing-Keys.patch

@@ -0,0 +1,34 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 21 Dec 2020 11:01:42 -0500
+Subject: [PATCH] Optimize Dynamic#get Missing Keys
+
+get was calling toString() on every NBT object that was ever asked for an optional
+key from the object to build a string for the error text.
+
+When done on large NBT objects, this was using a ton of computation time building the
+JSON representation of the NBT object.
+
+Now we will just skip the value when 99.9999% of the time the text is never even printed.
+
+diff --git a/src/main/java/com/mojang/serialization/Dynamic.java b/src/main/java/com/mojang/serialization/Dynamic.java
+index d73bb05272d69471644b28f8c704a3bfceca72c2..8b4ea53b891bb7a5ceb791c4afaaf33814d9b6f6 100644
+--- a/src/main/java/com/mojang/serialization/Dynamic.java
++++ b/src/main/java/com/mojang/serialization/Dynamic.java
+@@ -19,6 +19,7 @@ import java.util.stream.Stream;
+ 
+ @SuppressWarnings("unused")
+ public class Dynamic<T> extends DynamicLike<T> {
++    private static final boolean DEBUG_MISSING_KEYS = Boolean.getBoolean("Paper.debugDynamicMissingKeys"); // Paper - Perf: Skip toString on values like NBT
+     private final T value;
+ 
+     public Dynamic(final DynamicOps<T> ops) {
+@@ -120,7 +121,7 @@ public class Dynamic<T> extends DynamicLike<T> {
+         return new OptionalDynamic<>(ops, ops.getMap(value).flatMap(m -> {
+             final T value = m.get(key);
+             if (value == null) {
+-                return DataResult.error(() -> "key missing: " + key + " in " + this.value);
++                return DataResult.error(() -> DEBUG_MISSING_KEYS ? "key missing: " + key + " in " + this.value : "key missing: " + key); // Paper - Perf: Skip toString on values like NBT
+             }
+             return DataResult.success(new Dynamic<>(ops, value));
+         }));