Originally we simply warned if `FOO_DEP_VERSION` did not refer to a real
module; this was necessary as some modules had legacy (non-e3) dependencies
defined this way. However, this has the unfortunate side-effect that missing
_modules_ would "pass" the build, with a failure only happening if some
version of the module existed (but not the correct one).

See https://github.com/paulscherrerinstitute/require/commit/134aed5a5e618ae12a95134862401f1dcc92c834
for some context. Instead of searching recursively through .dbd files, one
can instead just filter source files for `%Record.(c|cc|cpp)`. This simplifies
the special python/tcl/pl script to handle dbd files.

This should take place after every single architecture has been finished. If any of them
fail, then the metadata file will _not_ be installed.

Previously, it was the case that running
```
$ iocsh -r module -l cellMods
$ iocsh -l cellMods -r module
```
would both work correctly, but if you looked at the IOC log it was not
clear why that was the case; in the former case it _appeared_ like we
were finding the module before setting `EPICS_DRIVER_PATH`. This only
worked because this variable is exported from the shell.

This change forces the `-l` flag to be processed _before_ all of the
other flags in order to ensure that paths are determined first.

Previously, the wrapper fixture would set some environment variables
when running `run_make`; this meant that you could not debug a test
case by simply navigating to the test directory and trying to build
the generated module. This change fixes that.

The ultimate issue here was that we performed a
```
cat $( ... ) | sed '1d'
```
and if that inner block was empty, then `cat` reverted to waiting for user input. The
error also came up with non-specified build numbers, so we need to make sure that those
are also being fetched correctly.

The upshot is now `<module>_VERSION` will automatically fetch the correct build number;
the only potential downside is that if we have a newer version in `${E3_SITEMODS_PATH}`
in comparison to `${EPICS_MODULES}` (read: cellMods), then it won't pick that up. However,
this seems to be a pretty special corner case.

This adds a test that checks that if a single architecture fails, then the build
fails as a whole.

There are some slight complications in terms of writing good tests, since we do not
want to use real architectures. Since the source files are converted from
`SOURCES -> SRCS -> LIBOBJS` and we finally have the dependency
```make
${DEPFILE}: ${LIBOBJS}
```
we need to ensure that `LIBOBJS` is properly populated before we get to this point.
The challenge, however, is that `LIBOBJS` is defined (in terms of `SRCS` as
```make
LIBOBJS += $(addsuffix $(OBJ),$(notdir $(basename $(filter-out %.$(OBJ) %$(LIB_SUFFIX),$(sort ${SRCS})))))
```
and `LIB_SUFFIX` is set in `${CONFIG}/os/CONFIG.Common.${T_A}`. This is why
we need to do the workaround of hand-defining it at the beginning.

This is necessary for the following reason: the previous mechanism used an
eval/call combination that required SUBS and TMPS to be exported on a previous
pass through. This allowed us to use `vpath` for each specific file in order
to locate the correct source files.

In order to avoid that, we add two new ingredients:
* `VPATH` instead of `vpath`, since it allows us to have variables
  that are expanded later
* `.SECONDEXPANSION`, which allows a target (`db_internal`, in this case) to
  perform a second variable expansion at the _end_ of the pass through.

All of this is necessary because the typical module makefile looks like:
```
include driver.makefile

SUBS += ...
```
i.e. `SUBS` and `TMPS` are defined _after_ the inclusion of driver.makefile. If
we don't want to force a re-write of every single module makefile, we needed
to do some of the above changes.

Note that there is something surprising here: `EXCLUDE_ARCHS` _filters_
the architectures (i.e. runs it as %arch%), while `ARCH_FILTER` matches
exactly. This is exactly backwards from what the names suggest.

However, I am leaving this as is for the time being since there are
possibly existing wrappers that use these two variables in this way; a
further investigation should be done to ensure that we can improve this
in some sense. If we make such a change, we should regard it as breaking.

In a dependency chain like B->A->C and also B->C where A needs a version
of C different than B the build should fail.
This commit adds this check during dependency treatment on the built
target.

* One test to catch invalid dependencies
* One test to catch architecture-dependent dependencies. Note that this itself does depend on
  the underlying architecture, which probably should be improved. But at the moment we only
  build for linux-based architectures, so this should be ok.

This was needed since we had to have a way for the test suites to override this value. However,
this can also be acheived by writing to configure/CONFIG_CELL.local. This was added in a
refactoring of run_make to make more clear what variables can be passed there.