Allow paths to be masked and captured by regex

Suggestion

Sometimes if we use a monorepo we will construct our monopackages like this:

packages
 - a
  - src/
    - index.ts
  - tsconfig.json
  - package.json
 - b
  - src/
    - index.ts
  - tsconfig.json
  - package.json
 - c
  - src/
    - index.ts
    - hello/
      - world.ts
  - tsconfig.json
  - package.json

So when we need to eject it as a git repo it is trivially done. However, I noticed that TypeScript path resolution is pretty limited to just simple replacement, how it is not working will be talked about later below. And I believe my examples are easier than my explanations :(

Scenario

Using babel-plugin-module-resolver, it was easy as pie:

const moduleResolver = [
  'babel-plugin-module-resolver', {
    'root': ['.'],
    'alias': {
      '^@app\/([^\/]+)\/?(.+)?': './packages/\\1/src/\\2'
    }
  }
]

But with the paths option of typescript, which only does simple substitution and is very useless that it could only accommodate one pattern star, is obviously much weaker in expressing power and cannot resolve context dependent subdirectories/submodules.

Examples

Consider this tsconfig

// Trying to use a common pattern to match "@app/{a,b,c}":
"paths": {
  "@app/*": ["packages/*/src"]
}
// Fine, what about "@app/c/hello/world"? It is actually substituted as packages/c/hello/world/src! 
// Doing a brute-force construction:
"paths": {
  "@app/a*": ["packages/a/src", "packages/a/src*"],
  "@app/b*": ["packages/b/src", "packages/b/src*"],
  "@app/c*": ["packages/c/src", "packages/c/src*"],
}
// It works but it wasn't elegant...consider if you have hundreds of monopackages and this would be hell
// Only if we could using a regex like pattern in babel-plugin-module-resolver:
"paths": {
  "^@app\/([^\/]+)\/?(.+)?": ["./packages/\\1/src/\\2"]
}
// Ah, much easier

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

Similar issues

https://github.com/Microsoft/TypeScript/issues/27298
https://github.com/Microsoft/TypeScript/issues/26787

Start with the issue's tsconfig paths examples and compare the requested regex captures with TypeScript's current path substitution behavior. Define how regex patterns and captured paths should interact with existing paths rules, then verify that monorepo imports such as @app/c/hello/world resolve to the intended package source path.