Если важна ТОЛЬКО скорость (а вариативность «так себе» ок), не ходите за тиками/системными вызовами и не трогайте крипто-API. Самый быстрый сид в управляемой среде — это монотонный счётчик + дешёвое перемешивание битов. Это одна атомарная операция и несколько целочисленных инструкций без переходов в ядро. Ниже готовые варианты для C++/CLI (.NET Framework, WinForms).

---

1) Сверхбыстрый и потокобезопасный 32-битный сид (чисто управляемый)

cpp
// FastSeed32.h
#pragma once
using namespace System;
using namespace System::Threading;

public ref class FastSeed32 sealed
{
private:
    static Int32 g; // CLR инициализирует нулём

public:
    // Одна атомарная операция + "аваланш"-миксы (Murmur3 fmix32)
    static __forceinline UInt32 Next()
    {
        UInt32 x = (UInt32)Interlocked::Increment(g); // уникальность в процессе
        x *= 0x9E3779B9u;                             // Weyl step (распространяет биты)

        // MurmurHash3 fmix32 — дешёвый и качественно рассеивает
        x ^= x >> 16; x *= 0x85EBCA6Bu;
        x ^= x >> 13; x *= 0xC2B2AE35u;
        x ^= x >> 16;
        return x;
    }
};

// FastSeed32.cpp
#include "FastSeed32.h"
Int32 FastSeed32::g = 0;

Почему это быстро: Interlocked::Increment — всего одна атомарная инстр. на шине + несколько умножений/сдвигов. Никаких вызовов ОС/таймеров. Для «пару тысяч» вызовов — идеально.
Вариативность: достаточно, чтобы сиды не были одинаковыми и хорошо «распылёнными» для обычного PRNG (xorshift/PCG и т.п.).

---

2) 64-битный сид (ещё ровнее распределение, всё так же быстро)

cpp
// FastSeed64.h
#pragma once
using namespace System;
using namespace System::Threading;

public ref class FastSeed64 sealed
{
private:
    static Int64 g; // счётчик

public:
    static __forceinline UInt64 Next()
    {
        // Weyl-последовательность: добавляем "золотую" константу атомарно
        const __int64 gamma = 0x9E3779B97F4A7C15ll;
        UInt64 x = (UInt64)Interlocked::Add(g, gamma);

        // SplitMix64 — эталонно дешёвый и «аваланшный» миксер
        x ^= x >> 30; x *= 0xBF58476D1CE4E5B9ull;
        x ^= x >> 27; x *= 0x94D049BB133111EBull;
        x ^= x >> 31;
        return x;
    }
};

// FastSeed64.cpp
#include "FastSeed64.h"
Int64 FastSeed64::g = 0;

Где удобно: если основной ГПСЧ 64-битный (PCG64, xoroshiro/ xoshiro и т.п.) — кормите его таким сидом напрямую или возьмите нижние 32 бита при необходимости.

---

3) «Чуть больше разнообразия, почти бесплатно»

Если хотите слегка «подсолить» счётчик без заметной потери скорости, подмешивайте аппаратный счётчик QPC не каждый раз, а, скажем, раз на 32 вызова:

cpp
using namespace System::Diagnostics;

static __forceinline UInt32 NextSeed32_Spiced()
{
    static Int32 g = 0;
    UInt32 x = (UInt32)Interlocked::Increment(g) * 0x9E3779B9u;

    // Раз в 32 вызова — QPC. Stopwatch::GetTimestamp() быстрый, но всё же дороже инкремента.
    if ((x & 31u) == 0u) {
        UInt64 t = (UInt64)Stopwatch::GetTimestamp();
        x ^= (UInt32)(t ^ (t >> 32));
    }

    // fmix32
    x ^= x >> 16; x *= 0x85EBCA6Bu;
    x ^= x >> 13; x *= 0xC2B2AE35u;
    x ^= x >> 16;
    return x;
}

Это остаётся очень быстрым: 31 вызов — только инкремент+миксы, 1 — с добавкой QPC.

---

4) Если «псевдоаппаратный/смешанный» всё же допустим — RDTSC (самый быстрый тайм-стамп)

Опционально. Вы писали, что «аппаратные способы» нежелательны, но «псевдоаппаратный/смешанный» вариант ок. Тогда лучший источник — __rdtsc() (без переходов в ядро):

cpp
#include <intrin.h>

static __forceinline UInt32 NextSeed32_TSC()
{
    UInt64 t = __rdtsc();           // десятки тактов, очень дёшево
    UInt32 x = (UInt32)(t ^ (t >> 32));
    // fmix32
    x ^= x >> 16; x *= 0x85EBCA6Bu;
    x ^= x >> 13; x *= 0xC2B2AE35u;
    x ^= x >> 16;
    return x;
}

На современных системах это, как правило, монотонный TSC и работает молниеносно. Если вызываете в плотной петле, добавьте Weyl-шаг x += 0x9E3779B9u; перед миксом, чтобы разнести соседние значения.

---

Почему не стоит делать так, как в вашем примере

cpp
static const uint32_t seed =
    static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&seed));

• Это почти константа: адрес статического символа в пределах процесса фиксирован, ASLR даёт мало разнообразия между запусками.
• Компилятор может агрессивно «закрыть» значение.
• В многопоточке вы получите одинаковые сиды.
• Разброс битов плохой — без микшера будут систематические корреляции.

---

Практические советы по скорости

• Не пересаживайте ГПСЧ слишком часто. Почти всегда быстрее создать один быстрый ГПСЧ (xoshiro/xoroshiro/PCG) и выдавать из него много чисел, чем генерировать тысячи сидов и каждый раз заново инициализировать ГПСЧ.
• Если сиды всё же нужны «пакетом», векторизуйте: вызовите Interlocked::Add(g, 32*gamma) один раз, а затем локально разверните 32 шага Weyl без атомиков.
• Избегайте DateTime::UtcNow, Guid::NewGuid(), RNGCryptoServiceProvider/RandomNumberGenerator — это на порядки медленнее (системные вызовы/крипто).

---

Если под ваш сценарий подходит «макс. скорость, умеренная уникальность» — берите вариант (1) или (2). Если допустимо «смешанное», и нужна чуть лучшая вариативность без потери скорости — добавьте специи из (3), либо напрямую используйте (4).