[flang] Clean up binary dependences of runtime libraries

[klausler]

Summary

There were dependences upon LLVM libraries in the Fortran
runtime support library binaries due to some indirect #includes
of llvm/Support/raw_ostream.h, which caused some kind of internal
ABI version consistency checking to get pulled in. Fixed by
cleaning up some includes.

[PeteSteinfeld]

All builds, tests, and looks good.

flang/include/flang/Common/enum-set.h

 
 // Implements a set of enums as a std::bitset<>.  APIs from bitset<> and set<>
 // can be used on these sets, whichever might be more clear to the user.
 // This class template facilitates the use of the more type-safe C++ "enum
 // class" feature without loss of convenience.
 
 #include "constexpr-bitset.h"
 #include "idioms.h"
-#include "llvm/Support/raw_ostream.h"
 #include <bitset>
 #include <cstddef>
 #include <initializer_list>
 #include <optional>
 #include <string>
 #include <type_traits>
 
 namespace Fortran::common {
public:
   template <typename FUNC> void IterateOverMembers(const FUNC &f) const {
     EnumSet copy{*this};
     while (auto least{copy.LeastElement()}) {
       f(*least);
       copy.erase(*least);
     }
   }
 
-  llvm::raw_ostream &Dump(
-      llvm::raw_ostream &o, std::string EnumToString(enumerationType)) const {
+  template <typename STREAM>
+  STREAM &Dump(STREAM &o, std::string EnumToString(enumerationType)) const {
     char sep{'{'};
     IterateOverMembers([&](auto e) {
       o << sep << EnumToString(e);
       sep = ',';
     });
     return o << (sep == '{' ? "{}" : "}");
   }
 

flang/lib/Decimal/big-radix-floating-point.h

 // a general-purpose facility.
 
 #include "flang/Common/bit-population-count.h"
 #include "flang/Common/leading-zero-bit-count.h"
 #include "flang/Common/uint128.h"
 #include "flang/Common/unsigned-const-division.h"
 #include "flang/Decimal/binary-floating-point.h"
 #include "flang/Decimal/decimal.h"
-#include "llvm/Support/raw_ostream.h"
 #include <cinttypes>
 #include <limits>
 #include <type_traits>
 
 namespace Fortran::decimal {
 
 static constexpr std::uint64_t TenToThe(int power) {
   return power <= 0 ? 1 : 10 * TenToThe(power - 1);
public:
   // cases, and will be the mean value when that is so (e.g., if
   // last decimal digit values 6-8 would all work, it'll be a 7).
   // This minimization necessarily assumes that the value will be
   // emitted and read back into the same (or less precise) format
   // with default rounding to the nearest value.
   void Minimize(
       BigRadixFloatingPointNumber &&less, BigRadixFloatingPointNumber &&more);
 
-  llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
+  template <typename STREAM> STREAM &Dump(STREAM &) const;
 
 private:
   BigRadixFloatingPointNumber(const BigRadixFloatingPointNumber &that)
       : digits_{that.digits_}, exponent_{that.exponent_},
         isNegative_{that.isNegative_}, rounding_{that.rounding_} {
     for (int j{0}; j < digits_; ++j) {
       digit_[j] = that.digit_[j];
     }

flang/lib/Decimal/binary-to-decimal.cpp

ConversionToDecimalResult ConvertLongDoubleToDecimal(char *buffer,
     enum FortranRounding rounding, long double x) {
   return Fortran::decimal::ConvertToDecimal(buffer, size, flags, digits,
       rounding, Fortran::decimal::BinaryFloatingPointNumber<64>(x));
 }
 #endif
 }
 
 template <int PREC, int LOG10RADIX>
-llvm::raw_ostream &BigRadixFloatingPointNumber<PREC, LOG10RADIX>::Dump(
-    llvm::raw_ostream &o) const {
+template <typename STREAM>
+STREAM &BigRadixFloatingPointNumber<PREC, LOG10RADIX>::Dump(STREAM &o) const {
   if (isNegative_) {
     o << '-';
   }
   o << "10**(" << exponent_ << ") * ...\n";
   for (int j{digits_}; --j >= 0;) {
     std::string str{std::to_string(digit_[j])};
     o << std::string(20 - str.size(), ' ') << str << " [" << j << ']';
     if (j + 1 == digitLimit_) {
       o << " (limit)";
     }
     o << '\n';
   }
   return o;
 }
 } // namespace Fortran::decimal

flang/lib/Semantics/mod-file.h

 //===-- lib/Semantics/mod-file.h --------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_SEMANTICS_MOD_FILE_H_
 #define FORTRAN_SEMANTICS_MOD_FILE_H_
 
 #include "flang/Semantics/attr.h"
+#include "llvm/Support/raw_ostream.h"
 #include <string>
 
 namespace Fortran::parser {
 class CharBlock;
 class Message;
 class MessageFixedText;
 } // namespace Fortran::parser
 

flang/runtime/transformational.cpp

 //===-- runtime/transformational.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "transformational.h"
 #include "memory.h"
 #include "terminator.h"
-#include "flang/Evaluate/integer.h"
 #include <algorithm>
 #include <cinttypes>
 
 namespace Fortran::runtime {
 
 static inline std::int64_t GetInt64(const char *p, std::size_t bytes) {
   switch (bytes) {
   case 1: