StringRepeat: Add support for generating longer strings & fix instantiations with unions

[som-sm]

Similar to #1042, StringRepeat currently can generate strings only upto length 90.

Why 90?

Looks like the compiler applies minor optimisations if we extract the recursive call using infer and then use the extracted type instead of the recursive call directly.

Let's consider an example: the following non-tail recursive implementation of GetChars fails at 50 characters.

type GetChars<S> = S extends `${infer Char}${infer Rest}`
  ? Char | GetChars<Rest>
  : never;

type FiftyZeroes = "00000000000000000000000000000000000000000000000000";

// Fails at 50 characters
type T1 = GetChars<FiftyZeroes>;
//        ~~~~~~~~~~~~~~~~~~~~~
//        Type instantiation is excessively deep and possibly infinite.

Playground

However, if we extract GetChars<Rest> into a separate type and then use the extracted type, the implementation starts working for upto 147 characters.

type GetChars<S> = S extends `${infer Char}${infer Rest}`
  ? GetChars<Rest> extends infer Result // Extract the result of the recursive call
    ? Char | Result // And then use it
    : never
  : never;

type FiftyZeroes = "00000000000000000000000000000000000000000000000000";

// Doesn't fail at 50 characters
type T2 = GetChars<FiftyZeroes>;

type HunderedFourtyEightZeroes =
  "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";

// Fails at 148 characters
type T3 = GetChars<HunderedFourtyEightZeroes>;
//        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//        Type instantiation is excessively deep and possibly infinite.

Playground

A similar thing happens in our existing implementation of StringRepeat. However, the test case I've added doesn’t consider this minor improvement, so it tests for 50 characters and not 91 characters.

This PR refactors StringRepeat to leverage tail recursion, allowing it to generate strings upto 1000 characters.

Other notes:

1. The existing implementation also doesn't work with unions, this PR fixes that as well.

    type T = StringRepeat<"foo" | "bar", 2>;
    // Actual: "foofoo" | "foobar" | "barfoo" | "barbar"
    // Expected: "foofoo" | "barbar"

2. Removed the use of Subtract because it was severely impacting the performance when used in a tail-recursive implementation.

   demo-compressed.mov