Sadly, this looks a bit off. The dots are not aligned properly.

A fix would be to use an array instead of align:

$$\begin{array}{rcl}
    a & \equiv & a_1 \pmod{m_1} \\
    a & \equiv & a_2 \pmod{m_2} \\
      & \vdots & \\
    a & \equiv & a_k \pmod{m_k}
\end{array}$$

Dito

\bmod{m_i} looks better here.

The transition to Garner's algorithm is a bit wonky. As Garner's algorithm computes the same thing, except with a worse time complexity...

If we add your explanation on the top, we should write a couple of word, like:
"Garners algorithm is an alternative approach for computing $a$. ..."

And I'm not sure if we should move this paragraph about representing a very large number using a system of smaller ones.
I want to keep it somewhere, as it's important. I think I used this technique a couple of times before. Where this really had some time benefit. But it's a bit lost in this section.

Btw, I'm not sure if you saw this (as I posted it on a closed issue). #1013

I think we should add an implementation. E.g. one in C++.
And we don't need to worry about large numbers. In most contests, as far as I remember, M is not that big, and usually fits inside an 32 bit integer. So doing all computations is with 64 bit integers is fine.
E.g. a prime example is Code Golf: Golf Gophers. The solution requires the CRT to find the solution, but all computations can be done without any big integer library.

And if it's not fine for some harder problem, then the reader can himself use/implement a big integer library or switch to some other language.
It's not necessary for an educational website to provide copy-pasteable snippets for every single usecase.

This here is my personal implementation for the algorithm you explained (with some different variable names though).

struct Congruence
{
    long long a, m, totient_m;
};

class CRT
{
public:
    void add_congruence(long long a, long long m, long long totient_m) {
        congruences.push_back({a, m, totient_m});
    }

    long long get_unique_solution() {
        long long M = 1;
        for (const auto& c : congruences) {
            M *= c.m;
        }

        long long solution = 0;
        for (const auto& c : congruences) {
            auto b = M / c.m;
            solution = (solution + c.a * b % M * power(b, c.totient_m - 1, c.m)) % M;
        }
        return solution;
    }

    std::vector<Congruence> congruences;
};

it makes more sense to write $M_j$ is a multiple of $m_i$, as you are computing $a \bmod m_i$ in the next line.