¿Son sobre programacion? Entonces ya esta respondido antes. ¿Son sobre como hace X cosa un S.O. Y? Tambien esta respondido antes. La realidad es que no hay un caudal minimo de preguntas ni usuarios interesados como para justificar un subforo de desarrollo de S.O.s en el foro de Programación (que ahi es donde deberia ir de existir).

¿Estas programando algo? Entonces las preguntas van en el subforo correspondiente al lenguaje que estes usando o en "Programación General" de no existir. Podria ir en "Ingeniería Inversa" una pregunta sobre como X S.O. implementa Y funcionalidad.

Esta mal en la segunda linea, lo que se borra de la pila es 3, no 10. Y en la primera linea no se borra menor, se borra siempre de la pila, coincide su valor con menor por obvias razones, por eso te dije antes que seria mas logico llamar a pop antes de empezar el bucle en lugar de comparar futilmente menor (que sabemos que es igual al resultado de top) con el resultado de top.

Esta claro que tenes problemas con la logica, si te resulta imposible imaginar lo que va haciendo el programa entonces tenes que depurarlo linea por linea, que es lo ideal, o cuanto menos ayudarte generando una salida en pantalla.

cout << "menor " << menor << " pila.top " << pila.top() << endl;  
if ( pila.top() < menor ) 
{
  cout << "CAMBIANDO menor, era " << menor << " sera " << pila.top() << endl; 
  menor = pila.top();
}

El valor de retorno de top es 10, no por ese comentario, es 10 por el simple hecho de que en la linea 21 el ultimo llamado a push tuvo como parametro 10. ¿Como puede ser que? ¿Que menor sea 10? Se le asigna ese valor en la linea 27. No hay ninguna incoherencia y una vez asignado el resultado de pila.top a menor, linea 27, deberias llamar a pila.pop, esa primera comparacion que haces es futil.

Ese 0x70 o 0xA0 esta muy pasado de los bytes necesarios para las 2 estructuras ya que estas empujando 8 bytes en cada iteracion del bucle. RCX deberia ser 0x10 (o simplemente restar 0x80) y despues deberias restarle 0x50 en lugar de 0x58.

Igual sinceramente no se que te impide acomodar la pila de una vez como hace el VC++.

Sin usar ninguna variable local tenes que restarle 0x58 a la pila, eso es lo minimo indispensable. 0x20 para el shadow space, 0x30 para los parametros que necesita la funcion (son 10 en total, 4 en registros y 6 en pila, 6 * 8 = 0x30) y 8 para alinear la pila a 16.

No me voy a poner a hacer ese trabajo a mano para las variables locales pero aca tenes un ejemplo generado por VC++:

  0000000000000000: 48 8B C4           mov         rax,rsp
  0000000000000003: 48 81 EC E8 00 00  sub         rsp,0E8h
                    00
  000000000000000A: 33 D2              xor         edx,edx
  000000000000000C: C7 40 08 63 6D 64  mov         dword ptr [rax+8],646D63h
                    00
  0000000000000013: 48 8D 48 8C        lea         rcx,[rax-74h]
  0000000000000017: 44 8D 42 64        lea         r8d,[rdx+64h]
  000000000000001B: E8 00 00 00 00     call        memset
  0000000000000020: 48 8D 44 24 50     lea         rax,[rsp+50h]
  0000000000000025: C7 44 24 70 68 00  mov         dword ptr [rsp+70h],68h
                    00 00
  000000000000002D: 48 89 44 24 48     mov         qword ptr [rsp+48h],rax
  0000000000000032: 48 8D 8C 24 F0 00  lea         rcx,[rsp+0F0h]
                    00 00
  000000000000003A: 48 8D 44 24 70     lea         rax,[rsp+70h]
  000000000000003F: 45 33 C9           xor         r9d,r9d
  0000000000000042: 48 89 44 24 40     mov         qword ptr [rsp+40h],rax
  0000000000000047: 45 33 C0           xor         r8d,r8d
  000000000000004A: 33 C0              xor         eax,eax
  000000000000004C: 33 D2              xor         edx,edx
  000000000000004E: 48 89 44 24 38     mov         qword ptr [rsp+38h],rax
  0000000000000053: 48 89 44 24 30     mov         qword ptr [rsp+30h],rax
  0000000000000058: 89 44 24 28        mov         dword ptr [rsp+28h],eax
  000000000000005C: C7 44 24 20 01 00  mov         dword ptr [rsp+20h],1
                    00 00
  0000000000000064: FF 15 00 00 00 00  call        qword ptr [__imp_CreateProcessA]
  000000000000006A: 33 C0              xor         eax,eax
  000000000000006C: 48 81 C4 E8 00 00  add         rsp,0E8h
                    00
  0000000000000073: C3                 ret

Al llamar a CreateProcessA en RSP + 0x20 arrancan los parametros (antes esta el shadow space), en RSP + 0x50 la estructura PROCESS_INFORMATION, en RSP + 0x70 la estructura STARTUPINFOA y en RSP + 0xF0 esta la cadena 'cmd\0'.

El entry point en Windows x64 esta alineado a 8 bytes. Teniendo en cuenta el ultimo codigo le estas restando 8 (primer push rdx), 0x400 - 0x80 * 8 - (push rdx dentro del loop) y 0x58 (sub rsp, 0x58). Un total de 0x460 y por lo tanto desalineado.

No, no se dice eso, sacaste la parte del prologo, DENTRO del prologo se puede dejar la pila desalineada momentaneamente, eso es lo que dice. Si todavia no entendes lo que esta dentro del prologo lee de nuevo:
https://en.wikipedia.org/wiki/Function_prologue_and_epilogue

¿A que se refiere con excepto? ¿Es una pregunta en serio? ¿De verdad? Me rindo por un tiempo.

Las instrucciones que momentaneamente pueden dejar la pila desalineada.

https://en.wikipedia.org/wiki/Function_prologue_and_epilogue

"There are basically two types of functions. A function that requires a stack frame is called a frame function. A function that does not require a stack frame is called a leaf function."
https://docs.microsoft.com/en-us/cpp/build/stack-usage?view=msvc-170

rdx edx dx dl
https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/x64-architecture