Add comments clarifying domain/finaliser guarantees

stdlib/domain.mli

@@ -183,7 +183,7 @@ module Safe : sig
       val for_initial_domain : t @@ nonportable
       (** [for_initial_domain] is a permanently available [t] that can be used by any
           top-level [nonportable] function safely, as such functions can only ever be
-          executed on the primary domain. *)
+          executed on the primary (initial) domain. *)
     end
 
     type 'a key : value mod portable contended = 'a DLS.key

stdlib/gc.mli

@@ -405,8 +405,6 @@ external get_minor_free : unit -> int = "caml_get_minor_free"
 
     @since 4.03 *)
 
-(* CR runtime5: We need finalisers registered on the primary domain to only ever
-   run on the primary domain. *)
 val finalise : ('a -> unit) -> 'a -> unit @@ nonportable
 (** [finalise f v] registers [f] as a finalisation function for [v].
    [v] must be heap-allocated.  [f] will be called with [v] as
@@ -426,6 +424,12 @@ val finalise : ('a -> unit) -> 'a -> unit @@ nonportable
    before the values it depends upon.  Of course, this becomes
    false if additional dependencies are introduced by assignments.
 
+   Finalisers are run by the domain which registered them, unless that
+   domain has already terminated in which case they may be run by some
+   other domain. Note that termination of the "primary" (initial) domain
+   ends the OCaml process, so finalisers registered by the initial domain
+   will only by run by that domain.
+
    In the presence of multiple OCaml threads it should be assumed that
    any particular finaliser may be executed in any of the threads.
 
@@ -485,6 +489,10 @@ val finalise_last : (unit -> unit) -> 'a -> unit @@ nonportable
     functions attached with {!finalise} are always called before the
     finalisation functions attached with {!finalise_last}.
 
+    As for {!finalise}, the finaliser is run by the domain which registered it,
+    unless that domain has already terminated in which case it may be run by
+    some other domain.
+
     @since 4.04
 *)