[flang] Give explicit convert= specifiers precedence over FORT_CONVERT

[jpenix-quic]

Summary

Currently, the FORT_CONVERT environment variable has the highest priority when
setting the endianness conversion for unformatted files. In discussing the
appropriate priority for the fconvert option, convert specifiers were decided
to take highest priority.

This patch also initializes the open statement convert state to unknown
to disambiguate cases where the convert specifier was not provided from
cases where convert=native was set. This makes it possible to defer to the
environment setting where appropriate.

flang/runtime/io-stmt.h

public:
   void CompleteOperation();
   int EndIoStatement();
 
 private:
   bool wasExtant_;
   std::optional<OpenStatus> status_;
   std::optional<Position> position_;
   std::optional<Action> action_;
-  Convert convert_{Convert::Native};
+  Convert convert_{Convert::Unknown};
   OwningPtr<char> path_;
   std::size_t pathLength_;
   std::optional<bool> isUnformatted_;
   std::optional<Access> access_;
 };
 
 class CloseStatementState : public ExternalIoStatementBase {
 public:

flang/runtime/unit.cpp

ExternalFileUnit *ExternalFileUnit::LookUpOrCreateAnonymous(int unit,
     const Terminator &terminator) {
   bool exists{false};
   ExternalFileUnit *result{
       GetUnitMap().LookUpOrCreate(unit, terminator, exists)};
   if (result && !exists) {
     IoErrorHandler handler{terminator};
     result->OpenAnonymousUnit(
         dir == Direction::Input ? OpenStatus::Unknown : OpenStatus::Replace,
-        Action::ReadWrite, Position::Rewind, Convert::Native, handler);
+        Action::ReadWrite, Position::Rewind, Convert::Unknown, handler);
     result->isUnformatted = isUnformatted;
   }
   return result;
 }
 
 ExternalFileUnit *ExternalFileUnit::LookUp(
     const char *path, std::size_t pathLen) {
   return GetUnitMap().LookUp(path, pathLen);
ExternalFileUnit &ExternalFileUnit::NewUnit(
   ExternalFileUnit &unit{GetUnitMap().NewUnit(terminator)};
   unit.createdForInternalChildIo_ = forChildIo;
   return unit;
 }
 
 void ExternalFileUnit::OpenUnit(std::optional<OpenStatus> status,
     std::optional<Action> action, Position position, OwningPtr<char> &&newPath,
     std::size_t newPathLength, Convert convert, IoErrorHandler &handler) {
-  if (executionEnvironment.conversion != Convert::Unknown) {
+  if (convert == Convert::Unknown) {
     convert = executionEnvironment.conversion;
   }
   swapEndianness_ = convert == Convert::Swap ||
       (convert == Convert::LittleEndian && !isHostLittleEndian) ||
       (convert == Convert::BigEndian && isHostLittleEndian);
   if (IsConnected()) {
     bool isSamePath{newPath.get() && path() && pathLength() == newPathLength &&
         std::memcmp(path(), newPath.get(), newPathLength) == 0};