Add support for FAKETIME_KEEP_BEFORE_NSEC_SINCE_EPOCH

`FAKETIME_KEEP_BEFORE_NSEC_SINCE_EPOCH` behaves similar to
`FAKETIME_START_AFTER_SECONDS`, with two main differences:

* the timestamp is absolute, instead of being relative to process startup
* the timestamp is specified in nanoseconds

The reason we want this feature is the following use case.

We run a large test suite under faketime. That test suite has access to
filesystem artifacts that were created prior to test start up.
Among those artifacts are some caches which are considered up to date
iff the timestamps of the files match what's recorded in a data structure.

This means that to access those caches to be considered valid we need their
timestamps to not be rewritten.

The reason we can't use `FAKETIME_START_AFTER_SECONDS` directly is that the
test suite consists of multiple processes, for those processes to correctly
interact with each other they need a consistent timestamp mapping that is shared
between them. In fact the simplest bash script already behaves incorrectly
because the commands use different process start times.

```
touch old
FAKETIME=+100d FAKETIME_START_AFTER_SECONDS=0 bash -c 'touch new; stat old new'
```

The expected behavior is that the timestamp of `old` is not rewritten,
while the timestamp of `new` is rewritten.

That is in fact achievable now:

```
touch old
now_ns=$(date +%s.%N | sed -r 's_\.__')
FAKETIME=+100d FAKETIME_KEEP_BEFORE_NSEC_SINCE_EPOCH="$now_ns" bash -c 'touch new; stat old new'
```

Author: aalekseyev

src/libfaketime.c

@@ -340,6 +340,9 @@ static int outfile = -1;
 
 static bool limited_faking = false;
 static long callcounter = 0;
+
+static long long ft_keep_before_nsec_since_epoch = -1;
+
 static long ft_start_after_secs = -1;
 static long ft_stop_after_secs = -1;
 static long ft_start_after_ncalls = -1;
@@ -2897,6 +2900,11 @@ static void ftpl_really_init(void)
     }
   }
 
+  if ((tmp_env = getenv("FAKETIME_KEEP_BEFORE_NSEC_SINCE_EPOCH")) != NULL)
+  {
+    ft_keep_before_nsec_since_epoch = atoll(tmp_env);
+    limited_faking = true;
+  }
   if ((tmp_env = getenv("FAKETIME_START_AFTER_SECONDS")) != NULL)
   {
     ft_start_after_secs = atol(tmp_env);
@@ -3220,9 +3228,15 @@ int fake_clock_gettime(clockid_t clk_id, struct timespec *tp)
         timespecsub(tp, &ftpl_starttime.real, &tmp_ts);
         break;
     }
-
     if (limited_faking)
     {
+      if (ft_keep_before_nsec_since_epoch != -1) {
+        long long tp_nsec = ((long long)tp->tv_sec) * 1000000000 + ((long long)tp->tv_nsec);
+        if (tp_nsec < ft_keep_before_nsec_since_epoch) {
+          ret = 0;
+          goto abort;
+        }
+      }
       /* Check whether we actually should be faking the returned timestamp. */
       /* fprintf(stderr, "(libfaketime limits -> runtime: %lu, callcounter: %lu\n", (*time_tptr - ftpl_starttime), callcounter); */
       if (((ft_start_after_secs != -1)    && (tmp_ts.tv_sec < ft_start_after_secs))