* Add support for skipping workloads testing for previous versions

This will skip installing manifests for 6, and 7, for example, and
install only install the latest ones. This is because on release
branches the newest versions might not have public packages available
yet.

* Set $(WorkloadsTestPreviousVersions) in the yml

.. based on the branch. Set it to `true` only for `main`.

* Versions.props: Increment package versions for 6.0, and 7.0

* Set WorkloadsTestPreviousVersions=true by default

* Set default for WorkloadsTestPreviousVersions

 ## Background:

`eng/pipelines/common/evaluate-default-paths.yml` is used to specify named subsets of paths, and `evaluate-changed-paths.sh` decides which subsets have "changed files". And these subsets are used in conditions for the various jobs to determine when they should be run.

---
`evaluate-changed-paths.sh: Add support for include+exclude combined`

 ## Problem

This script currently supports `--include`, and `--exclude`
parameters to determine if we have any changed paths.

```
Scenarios:
1. exclude paths are specified
    Will include all paths except the ones in the exclude list.
2. include paths are specified
    Will only include paths specified in the list.
1st we evaluate changes for all paths except ones in excluded list. If we can not find
any applicable changes like that, then we evaluate changes for included paths
if any of these two finds changes, then a variable will be set to true.
```

As described above, these two are evaluated exclusively.
For example:

```
include: [ '/a/b/*' ], exclude: [ '/a/b/d.txt' ]
```

- This would return true if there are changes:
  - `[ '/a/b/c.txt' ]` - caught by `include`
  - or `[ '/r/s.txt' ]` - caught by `exclude`

- but it would also return true for `[ '/a/b/d.txt' ]` because `include`
does not consider the `exclude` list.

 ## Solution:

- This commit adds a new `--combined` parameter which essentially supports
`$include - $exclude`. Thus allowing exact more constrained path
specification.

- It is passed in addition to `include`, and `exclude`.

Given:
```
include: [ '/a/b/*' ], exclude: [ '/a/b/d.txt' ]
```

- For the following path changes:
  - `[ '/a/b/c.txt' ]` - `true`
  - `[ '/r/s.txt' ]` - `false` because this does not fall in
    `$include - $exclude`
  - `[ '/a/b/d.txt' ]` - `false` - excluded in `$include - $exclude`

The implementation is trivially implemented by passing both the lists to
`git diff` which supports this already.

---

- Track subset name changes in the ymls
- Update `wasm` jobs to have tighter trigger conditions

- This results in wasm specific changes only triggering relevant wasm jobs. For example, if there are wasm debugger changes then only the wasm debugger jobs will be triggered. Or if there are only workload manifest[1] changes then Wasm.Build.Tests will be triggered only.

- For PRs with strictly wasm only changes, disables running non-wasm jobs like mobile, or coreclr
- For Wasm.Build.Tests, and debugger only PRs, runs only those jobs
- Run coreclr jobs only if the PR has non-mono/wasm changes

[wasm] Split `runtime-wasm` pipeline into `runtime-wasm-libtests`, and `runtime-wasm-non-libtests` (#74859)

Adds two new pipelines:
- `runtime-wasm-libtests` - runs all the wasm library tests
- `runtime-wasm-non-libtests` - runs all the wasm non-library tests like WBT, debugger etc.

And `runtime-wasm` runs the combination of the two above.

- For all 3 pipelines, jobs are run only if they weren't run on the default (`runtime`) pipeline

## Which pipeline should I run?

* if `runtime` didn't run the tests that would be useful for testing the changes, then:
  - If the changes only relate to libraries, the runtime, then use `runtime-wasm-libtests`
  - If the changes only affect `Wasm.Build.Tests`, or debugger tests, or runtime tests, then use `runtime-wasm-non-libtests`
  - Use `runtime-wasm` when you want to run *all* the wasm tests

# Updated CI matrix for wasm

## PR:

* `only-pc` means `only on relevant path changes`

### Run by default

* `runtime` runs jobs only when relevant paths change. And for `AOT`, only smoke tests are run.

| .                 | runtime                       |
| ----------------- | --------------------          |
| libtests          | linux+windows: all,   only-pc |
| libtests eat      | linux+windows: smoke, only-pc |
| libtests aot      | linux+windows: smoke, only-pc |
| high resource aot | none                          |
| Wasm.Build.Tests  | linux+windows:        only-pc |
| Debugger tests    | linux+windows:        only-pc |
| Runtime tests     | linux+windows:        only-pc |


### Run manually with `/azp run ..`

* `runtime-wasm*` pipelines are triggered manually, and they only run the jobs that would not run on any default pipelines based on path changes.
* The `AOT` jobs run only smoke tests on `runtime`, and on `runtime-wasm*` pipelines all the `AOT` tests are run.

| .                 | runtime-wasm               | runtime-wasm-libtests | runtime-wasm-non-libtests |
| ----------------- | -------------------------- | --------------------  | --------------------      |
| libtests          | linux+windows: all         | linux+windows: all    | none                      |
| libtests eat      | linux:         all         | linux:         all    | none                      |
| libtests aot      | linux+windows: all         | linux+windows: all    | none                      |
| high resource aot | linux+windows: all         | linux+windows: all    | none                      |
| Wasm.Build.Tests  | linux+windows              | none                  | linux+windows             |
| Debugger tests    | linux+windows              | none                  | linux+windows             |
| Runtime tests     | linux                      | none                  | linux                     |
| Perftrace         | linux: all tests           | linux: all tests      |                           |
| Multi-thread      | linux: all tests           | linux: all tests      |                           |

* `runtime-extra-platforms` does not run any wasm jobs on PRs
* `high resource aot` runs a few specific library tests with AOT, that require more memory to AOT.

## Rolling build (twice a day):

* `runtime` runs all the wasm jobs, but `AOT` still only runs smoke tests.
* `runtime-extra-platforms` also runs by default. And it runs only the cases not covered by `runtime`.

| .                 | runtime                    | runtime-extra-platforms (always run) |
| ----------------- | -------------              | ------------------------------------ |
| libtests          | linux+windows: all         | none                                 |
| libtests eat      | linux: all                 | none                                 |
| libtests aot      | linux+windows: smoke       | linux+windows: all                   |
| high resource aot | none                       | linux+windows: all                   |
|                   |                            |                                      |
| Wasm.Build.Tests  | linux+windows              | none                                 |
| Debugger tests    | linux+windows              | none                                 |
| Runtime tests     | linux                      | none                                 |
| Perftrace         | linux: build only          | none                                 |
| Multi-thread      | linux: build only          | none                                 |

* `high resource aot` runs a few specific library tests with AOT, that require more memory to AOT.

* CI: On runtime-wasm skip the jobs that would run on runtime

* CI: Enable evaluate-default-paths for runtime-wasm

* CI: In runtime-extra-platforms, run wasm jobs only on rolling builds

## Issue

Currently, whenever a darc flow PR is opened, we cannot trigger different jobs based on which
dependency got updated. This is needed because in some cases, like for ILLinker, Emscripten
updates we want to trigger all the wasm jobs. But that might not be needed for some of the other
dependencies.

- This causes failures to slip through to `main`, which gets discovered after the fact as other PR
failures, or rolling build failures, creating extra work for developers.

## Solution

- This PR identifies the changed dependencies, and emits one azure variable per dependency,
which can then be used in conditions in the yml .
- The changed dependency can be checked as `dependencies.evaluate_paths.outputs['DarcDependenciesChanged.System_CommandLine']`

- Included this in the `evaluate_paths` job itself, instead of creating another job

- Also, use this for wasm jobs

* xplat-setup.yml: Add support for setting `shouldContinueOnError` to

.. `false`.

Currently, xplat-setup.yml passes on `shouldContinueOnError` to the
template with `true` if the parameter was `true`, else it sets the value
based on whether this is for runtime-staging, on a PR.

Which essentially means that runtime-staging defaults to
`shouldContinueOnError: true` for PRs, or we can set it explcitly to
`true` which would affect the rolling builds.

But this does not allow making a runtime-staging job *fail* when *tests
fail*. To support that this change adds a check for a special value
`forceFalse`, which causes the param to explicitly set to `false`. Thus
allowing `runtime-staging` builds to be marked as such.

* [wasm] Add more paths to trigger running tests on CI

* fix comment

* [wasm] Trigger all wasm jobs, if eng/Version.Details.xml has any changes, so we run a full check on emsdk updates

* fix yml

* Fix merge

* [wasm] Pass isRollingBuild to runtime-extra-platforms-wasm template, to correctly trigger the EAT/AOT builds

* .. and pass isWasmOnlyBuild also

* Rationalize wasm jobs run on CI

Essentially:
- For rolling builds, we want to run all the wasm jobs, unconditionally
   - And `runtime-extra-platforms` runs the tests that were not in `runtime`, and `runtime-staging`
- For PRs, we use the various path checks

Changes:
- split wasm jobs into various templates
- combine, and simplify some jobs

* `runtime-extra-platforms`, and `runtime-wasm` run only when manually
  triggered with a comment - `/azp run <pipeline-name>`
* `runtime`, and `runtime-staging`, run jobs only when relevant paths
  change. And for `EAT`, and `AOT`, only smoke tests are run.
* And when `runtime-wasm` is triggered manually, it runs *all* the wasm
  jobs completely

| .                 | runtime               | runtime-staging         | runtime-extra-platforms(manual only) | runtime-wasm (manual only) |
| ----------------- | --------------------  | ---------------         | ------------------------------------ | -------                    |
| libtests          | linux: all,   only-pc | windows: all,   only-pc | linux+windows: all, only-pc          | linux+windows: all, always |
| libtests eat      | linux: smoke, only-pc | -                       | linux:         all, only-pc          | linux:         all, always |
| libtests aot      | linux: smoke, only-pc | windows: smoke, only-pc | linux+windows: all, only-pc          | linux+windows: all, always |
|                   |                       |                         |                                      |                            |
| Wasm.Build.Tests  | linux:        only-pc | windows:        only-pc | linux+windows: only-pc               | linux+windows              |
| Debugger tests    | -                     | linux+windows:  only-pc | linux+windows: only-pc               | linux+windows              |
| Runtime tests     | linux:        only-pc | -                       | linux: only-pc                       | linux                      |

* `runtime`, and `runtime-staging`, run all the wasm jobs unconditionally, but `EAT`, and `AOT` still run only smoke tests.
* `runtime-extra-platforms` also runs by default. And it runs only the cases not covered by the above two pipelines.

* jobs w/o `only-pc` are always run

| .                 | runtime                   | runtime-staging       | runtime-extra-platforms (always run) | runtime-wasm (manual only) |
| ----------------- | -------------             | ---------------       | ------------------------------------ | ------                     |
| libtests          | linux: all(v8/chr/node)   | windows: all          | linux+windows: all with node         | N/A                        |
| libtests eat      | linux: smoke              | -                     | linux: all                           |                            |
| libtests aot      | linux: smoke              | windows: smoke        | linux+windows: all                   |                            |
|                   |                           |                       |                                      |                            |
| Wasm.Build.Tests  | linux: always             | windows: always       | none                                 |                            |
| Debugger tests    | -                         | linux+windows: always | none                                 |                            |
| Runtime tests     | linux: always             | -                     | none                                 |                            |

* [wasm] Run tests with node only on runtime-wasm