Applying random time delay offsets looks like AWGN. Why?

[pfeatherstone]

So I'm experimenting with some synthetic noisers. I've played with random sample rate offsets (exactly the same as sro_model in GNURadio) that applies a Gaussian random walk offset to the sample rate. That behaves well.
So I thought I would try something simpler and add a Gaussian random offset to the time delay. This is slightly different.
Here is the code and some figures:

#include <vector>
#include <complex>
#include <liquid/liquid.h>
#include "matplotlibcpp.h"

using namespace std;
namespace plt = matplotlibcpp;

/*! HELPERS !*/
vector<float> real(const vector<complex<float>>& z)
{
    vector<float> r(z.size());
    std::transform(z.begin(), z.end(), r.begin(), [](const complex<float>& x) {return x.real();});
    return r;
}

vector<float> imag(const vector<complex<float>>& z)
{
    vector<float> r(z.size());
    std::transform(z.begin(), z.end(), r.begin(), [](const complex<float>& x) {return x.imag();});
    return r;
}
/*! HELPERS !*/

vector<complex<float>> make_example_signal(int nsamples)
{
    int          ftype   = LIQUID_FIRFILT_ARKAISER;
    unsigned int k       =     2;
    unsigned int m       =     9;
    float        beta    = 0.30f;
    int          ms      = LIQUID_MODEM_BPSK;
    symstreamcf  gen     = symstreamcf_create_linear(ftype,k,m,beta,ms);

    vector<complex<float>> iq(nsamples);
    symstreamcf_write_samples(gen, iq.data(), iq.size());
    symstreamcf_destroy(gen);

    return iq;
}

vector<float> spectrum(const vector<complex<float>>& iq, int nfft)
{
    spgramcf obj = spgramcf_create_default(nfft);
    vector<float> spec(nfft);
    spgramcf_write(obj, (liquid_float_complex*)iq.data(), iq.size());
    spgramcf_get_psd(obj, spec.data());
    spgramcf_destroy(obj);
    return spec;
}

vector<complex<float>> random_delays(
    const vector<complex<float>>& iq,
    float delay_mean  = 0,
    float delay_stdev = 0.1f,
    float delay_min = -0.5f,
    float delay_max = +0.5f
)
{
    const int M     = 128;
    const int m     = 10;
    firpfb_crcf q   = firpfb_crcf_create_default(M, m);

    int h_index = 0;
    float time_in  = -1;
    float time_out = 0;
    int   time_out_exact = 0;

    auto get_index = [&] {
        return (int)round((time_out - time_in) * M);
    };

    vector<complex<float>> out;

    for (size_t i = 0 ; i < iq.size() ; i++)
    {
        //push input and increment input time offset
        firpfb_crcf_push(q, iq[i]);
        time_in += 1;

        while ((h_index = get_index()) < M)
        {
            //execute
            complex<float> z;
            firpfb_crcf_execute(q, h_index, &z);
            out.push_back(z);
            //increment output time offset
            time_out = (++time_out_exact) + std::min(std::max(randnf() * delay_stdev + delay_mean, delay_min), delay_max);
        }
    }

    //remove filter delay
    std::rotate(out.begin(), out.begin() + m, out.end());
    return out;
}

int main()
{
    auto iq1 = make_example_signal(1024);
    auto iq2 = random_delays(iq1, 0, 0.25, -0.5,+0.5);

    plt::figure();
    plt::named_plot("ori", spectrum(iq1, 512));
    plt::named_plot("delays", spectrum(iq2, 512));
    plt::legend();

    plt::figure();
    plt::named_plot("ori (I)",real(iq1));
    plt::named_plot("delays (I)",real(iq2));
    plt::legend();

    plt::figure();
    plt::named_plot("ori (Q)",imag(iq1));
    plt::named_plot("delays (Q)",imag(iq2));
    plt::legend();

    plt::show();

    return 0;
}

Here are the plots:

Now you can see in the second plot (I) that tiny time offsets are applied. That's great, that was the intention.
Looking at the first plot, the spectra, it looks like AWGN!

But why?

[jgaeddert]

You might need to plot the full signal to see what's happening; not just the first 140 samples or so.

[pfeatherstone]

It's more of the same to be honest.