Put functional tests in `tests/functional`

I think it is bad for these reasons when `tests/` contains a mix of
functional and integration tests

 - Concepts is harder to understand, the documentation makes a good
   unit vs functional vs integration distinction, but when the
   integration tests are just two subdirs within `tests/` this is not
   clear.

 - Source filtering in the `flake.nix` is more complex. We need to
   filter out some of the dirs from `tests/`, rather than simply pick
   the dirs we want and take all of them. This is a good sign the
   structure of what we are trying to do is not matching the structure
   of the files.

With this change we have a clean:
```shell-session
$ git show 'HEAD:tests'
tree HEAD:tests

functional/
installer/
nixos/
```

(cherry picked from commit 68c81c737571794f7246db53fb4774e94fcf4b7e)

1 files changed, 0 insertions, 80 deletions

diff --git a/tests/dyn-drv/eval-outputOf.sh b/tests/dyn-drv/eval-outputOf.sh
deleted file mode 100644
index 9467feb8d..000000000
--- a/tests/dyn-drv/eval-outputOf.sh
+++ /dev/null
@@ -1,80 +0,0 @@
-#!/usr/bin/env bash
-
-source ./common.sh
-
-# Without the dynamic-derivations XP feature, we don't have the builtin.
-nix --experimental-features 'nix-command' eval --impure  --expr \
-    'assert ! (builtins ? outputOf); ""'
-
-# Test that a string is required.
-#
-# We currently require a string to be passed, rather than a derivation
-# object that could be coerced to a string. We might liberalise this in
-# the future so it does work, but there are some design questions to
-# resolve first. Adding a test so we don't liberalise it by accident.
-expectStderr 1 nix --experimental-features 'nix-command dynamic-derivations' eval --impure --expr \
-    'builtins.outputOf (import ../dependencies.nix {}) "out"' \
-    | grepQuiet "value is a set while a string was expected"
-
-# Test that "DrvDeep" string contexts are not supported at this time
-#
-# Like the above, this is a restriction we could relax later.
-expectStderr 1 nix --experimental-features 'nix-command dynamic-derivations' eval --impure --expr \
-    'builtins.outputOf (import ../dependencies.nix {}).drvPath "out"' \
-    | grepQuiet "has a context which refers to a complete source and binary closure. This is not supported at this time"
-
-# Test using `builtins.outputOf` with static derivations
-testStaticHello () {
-    nix eval --impure --expr \
-        'with (import ./text-hashed-output.nix); let
-           a = hello.outPath;
-           b = builtins.outputOf (builtins.unsafeDiscardOutputDependency hello.drvPath) "out";
-         in builtins.trace a
-           (builtins.trace b
-             (assert a == b; null))'
-}
-
-# Test with a regular old input-addresed derivation
-#
-# `builtins.outputOf` works without ca-derivations and doesn't create a
-# placeholder but just returns the output path.
-testStaticHello
-
-# Test with content addressed derivation.
-NIX_TESTS_CA_BY_DEFAULT=1 testStaticHello
-
-# Test with derivation-producing derivation
-#
-# This is hardly different from the preceding cases, except that we're
-# only taking 1 outputOf out of 2 possible outputOfs. Note that
-# `.outPath` could be defined as `outputOf drvPath`, which is what we're
-# testing here. The other `outputOf` that we're not testing here is the
-# use of _dynamic_ derivations.
-nix eval --impure --expr \
-    'with (import ./text-hashed-output.nix); let
-       a = producingDrv.outPath;
-       b = builtins.outputOf (builtins.builtins.unsafeDiscardOutputDependency producingDrv.drvPath) "out";
-     in builtins.trace a
-       (builtins.trace b
-         (assert a == b; null))'
-
-# Test with unbuilt output of derivation-producing derivation.
-#
-# This function similar to `testStaticHello` used above, but instead of
-# checking the property on a constant derivation, we check it on a
-# derivation that's from another derivation's output (outPath).
-testDynamicHello () {
-    nix eval --impure --expr \
-        'with (import ./text-hashed-output.nix); let
-           a = builtins.outputOf producingDrv.outPath "out";
-           b = builtins.outputOf (builtins.outputOf (builtins.unsafeDiscardOutputDependency producingDrv.drvPath) "out") "out";
-         in builtins.trace a
-           (builtins.trace b
-             (assert a == b; null))'
-}
-
-# inner dynamic derivation is input-addressed
-testDynamicHello
-
-# inner dynamic derivation is content-addressed
-NIX_TESTS_CA_BY_DEFAULT=1 testDynamicHello