[libc] Remove global constructors on File type

[jhuber6]

Summary

The File interface currently has a destructor to delete the buffer if
it is owned by the file. This is problematic for the globally allocated
stdout, stdin, and stderr files. This causes the file interface to
have global constructors to initialize the destructors to use these.
However, these never use the destructors because they don't own the
buffer. This patch removes the destructor and calls in manually in the
close implementation. The platform close should never need to access the
buffer and it needs to be done before clearing the whole thing, so this
should work.

libc/src/__support/File/file.h

return mode & (static_cast<ModeFlags>(OpenMode::WRITE) |
                    static_cast<ModeFlags>(OpenMode::PLUS));
   }
 
   constexpr bool read_allowed() const {
     return mode & (static_cast<ModeFlags>(OpenMode::READ) |
                    static_cast<ModeFlags>(OpenMode::PLUS));
   }
 
-  // The GPU build should not emit a destructor because we do not support global
-  // destructors in all cases and it is unneccessary without buffering.
-#if !defined(LIBC_TARGET_ARCH_IS_GPU)
-  ~File() {
-    if (own_buf)
-      delete buf;
-  }
-#endif
-
 public:
   // We want this constructor to be constexpr so that global file objects
   // like stdout do not require invocation of the constructor which can
   // potentially lead to static initialization order fiasco. Consequently,
   // we will assume that the |buffer| and |buffer_size| argument are
   // meaningful - that is, |buffer| is nullptr if and only if |buffer_size|
   // is zero. This way, we will not have to employ the semantics of
   // the set_buffer method and allocate a buffer.
int close() {
       if (prev_op == FileOp::WRITE && pos > 0) {
         auto buf_result = platform_write(this, buf, pos);
         if (buf_result.has_error() || buf_result.value < pos) {
           err = true;
           return buf_result.error;
         }
       }
     }
+
+    // If we own the buffer, delete it before calling the platform close
+    // implementation. The platform close should not need to access the buffer
+    // and we need to clean it up before the entire structure is removed.
+    if (own_buf)
+      delete buf;
+
     // Platform close is expected to cleanup the file data structure which
     // includes the file mutex. Hence, we call platform_close after releasing
     // the file lock. Another thread doing file operations while a thread is
     // closing the file is undefined behavior as per POSIX.
     return platform_close(this);
   }
 
   // Sets the internal buffer to |buffer| with buffering mode |mode|.