Réponse acceptée !
Voila ce que ça donne (testé et approuvé par un échantillon de une personne) :

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TAutoTerminateThread = class(TThread)
  private
    FMainWndHandle: THandle;
    FTerminateTime: TDateTime;
    FWaitEvent: Cardinal;
  protected
    procedure Execute; override;
  public
    constructor Create(MainWindowHandle: THandle; EndTime: TDateTime);
    destructor Destroy; override;
    { Obligé de réintroduire cette méthode car on utilise un TEvent,
    ce qui n'est malheureusement pas géré nativement par Delphi }
    procedure Terminate; reintroduce;
  end;

  TFrmTest = class(TForm)
    BtnQuit: TButton;
    BtnPlante: TButton;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure BtnQuitClick(Sender: TObject);
    procedure BtnPlanteClick(Sender: TObject);
  private
    FTermThread: TAutoTerminateThread;
  end;

var
  FrmTest: TFrmTest;

implementation

{$R *.dfm}

constructor TAutoTerminateThread.Create(MainWindowHandle: THandle;
  EndTime: TDateTime);
begin
  inherited Create(False);
  FreeOnTerminate := True;
  FMainWndHandle := MainWindowHandle;
  FTerminateTime := EndTime;
  FWaitEvent := CreateEvent(nil, True, False, nil);
  if FWaitEvent = 0 then
    RaiseLastOSError;
end;

destructor TAutoTerminateThread.Destroy;
begin
  CloseHandle(FWaitEvent);
  inherited Destroy;
end;

procedure TAutoTerminateThread.Terminate;
begin
  SetEvent(FWaitEvent);
  inherited Terminate;
end;

procedure TAutoTerminateThread.Execute;
var
  WaitTime: Cardinal;
begin
  WaitTime := Trunc(FTerminateTime - Now) * 1000;
  if WaitForSingleObject(FWaitEvent, WaitTime) = WAIT_TIMEOUT then
  begin
    {>> On n'a fait pas appel à Terminate et le temps s'est écoulé: on quitte }

    { D'abord, la méthode "douce" (pas SendMessage car si l'autre thread
    est bloqué, celui-ci aussi va se bloquer) }
    PostMessage(FMainWndHandle, WM_CLOSE, 0, 0);

    { On attend encore un peu pour voir si l'autre thread fait
    appel à Terminate ou s'il est vraiment coincé (5 secondes maxi) }
    if WaitForSingleObject(FWaitEvent, 5000) = WAIT_TIMEOUT then
    begin
      { Coinçage total: suicide obligé ! }
      Beep;
      TerminateProcess(GetCurrentProcess, 1);
    end;
  end;
end;

procedure TFrmTest.FormCreate(Sender: TObject);
begin
  {>> Le programme va se fermer 5 secondes après son ouverture }
  FTermThread := TAutoTerminateThread.Create(Handle, Now + 5.0);
end;

procedure TFrmTest.FormDestroy(Sender: TObject);
begin
  {>> On signale au thread de se terminer: la procédure WaitForSingleObject
  renvoit immédiatement WAIT_OBJECT_0 et le thread se détruit normelement }
  FTermThread.Terminate;
end;

procedure TFrmTest.BtnQuitClick(Sender: TObject);
begin
  Close;
end;

procedure TFrmTest.BtnPlanteClick(Sender: TObject);
begin
  while True do
    Sleep(10);
end;

end.

Alors, qu'en pensez-vous ?