Confusing "exception is discarded" in exceptions#how-exceptions-are-handled page

[jinek]

The page: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/exceptions#how-exceptions-are-handled
(source: https://github.com/dotnet/csharplang/blob/master/spec/exceptions.md)
contains:

If there is no base class (as in the case of the object type) or if there is no base class destructor, then the exception is discarded.

The statement "no base class destructor" is not clear, because any type has in its hierarchy System.Object which has desctructor. This way the sentance is logically always false and does not make sense.

If that stands for the direct base class, then the statement "exception is discarded" is not true as seen by running this application:

internal class Program
    {       
        public static void Main(string[] args)
        {
            AppDomain.CurrentDomain.UnhandledException += (sender, eventArgs) =>
            {
                Console.WriteLine("Exception in AppDomain:" + ((Exception)eventArgs.ExceptionObject).Message);
            };

            new ChildClass();
            
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
            
            Console.WriteLine("Program has executed. No exceptions hit the stack root");
            Console.ReadLine();
        }
    }

    internal class ChildClass : ParentClass
    {
        ~ChildClass()
        {
          Console.WriteLine("Child finalizer");
          throw new InvalidOperationException("Is child exception discarded?");
        }
    }

    internal class ParentClass
    {
        
    }

The result is

Child finalizer
Exception in AppDomain:Is child exception discarded?

Unhandled Exception: System.InvalidOperationException: Is child exception discarded?
   at ConsoleApplication4.ChildClass.Finalize() 

Process finished with exit code -532,462,766.

Which means that exception from finalizer hits the root of the stack which then is handled as any other exception thrown not from finalizers.

This particular article is used as a reference in some other documentation parts.