Split Semantics into Check and SemIR namespaces (#3138)

Splits IR files into SemIR, and logic files into Check. These will be
split into separate directories as part of a later move; the namespaces
are being done first in order to vet the switch, and hopefully make
conflicts a little easier to manage due to the substantial renames.

A lot of this is just automated removal of Semantics prefixes from
names, adding namespace references where needed. A few special-cases
are:

- SemanticsIR -> SemIR::File
- A few things were discussed, like Unit, CompileUnit, or CompiledUnit.
Unit was too vague for chandlerc, and I thought CompileUnit might lead
to incorrect inferences (CompilationUnit would be more precise, but
typically written as SemIR::CompilationUnit which is pretty long). File
seemed to be a short name that we could agree on.
- SemanticsIRFormatter -> SemIR::Formatter
- FormatSemanticsIR -> SemIR::FormatFile
- SemanticsFileTest -> CheckFileTest
- It remains in the Testing namespace, where just "FileTest" might be
too broad a name.
- SemanticsDeclarationNameStack::Context ->
Check::DeclarationNameStack::NameContext
  - This avoids a Check::Context name shadowing.

Changes check_internal.h to include ostream.h to improve finding of
Print/operator<< (otherwise it didn't compile).

This is part of #3070

toolchain/semantics/semantics_handle_array.cpp

@@ -7,22 +7,21 @@
 #include "toolchain/semantics/semantics_node.h"
 #include "toolchain/semantics/semantics_node_kind.h"
 
-namespace Carbon {
+namespace Carbon::Check {
 
-auto SemanticsHandleArrayExpressionStart(SemanticsContext& /*context*/,
-                                         ParseTree::Node /*parse_node*/)
-    -> bool {
+auto HandleArrayExpressionStart(Context& /*context*/,
+                                ParseTree::Node /*parse_node*/) -> bool {
   return true;
 }
 
-auto SemanticsHandleArrayExpressionSemi(SemanticsContext& context,
-                                        ParseTree::Node parse_node) -> bool {
+auto HandleArrayExpressionSemi(Context& context, ParseTree::Node parse_node)
+    -> bool {
   context.node_stack().Push(parse_node);
   return true;
 }
 
-auto SemanticsHandleArrayExpression(SemanticsContext& context,
-                                    ParseTree::Node parse_node) -> bool {
+auto HandleArrayExpression(Context& context, ParseTree::Node parse_node)
+    -> bool {
   // TODO: Handle array type with undefined bound.
   if (context.parse_tree().node_kind(context.node_stack().PeekParseNode()) ==
       ParseNodeKind::ArrayExpressionSemi) {
@@ -36,22 +35,22 @@ auto SemanticsHandleArrayExpression(SemanticsContext& context,
       .PopAndDiscardSoloParseNode<ParseNodeKind::ArrayExpressionSemi>();
   auto element_type_node_id = context.node_stack().PopExpression();
   auto bound_node = context.semantics_ir().GetNode(bound_node_id);
-  if (bound_node.kind() == SemanticsNodeKind::IntegerLiteral) {
+  if (bound_node.kind() == SemIR::NodeKind::IntegerLiteral) {
     auto bound_value = context.semantics_ir().GetIntegerLiteral(
         bound_node.GetAsIntegerLiteral());
     if (!bound_value.isNegative()) {
       context.AddNodeAndPush(
           parse_node,
-          SemanticsNode::ArrayType::Make(
-              parse_node, SemanticsTypeId::TypeType, bound_node_id,
+          SemIR::Node::ArrayType::Make(
+              parse_node, SemIR::TypeId::TypeType, bound_node_id,
               context.ExpressionAsType(parse_node, element_type_node_id)));
       return true;
     }
   }
   CARBON_DIAGNOSTIC(InvalidArrayExpression, Error, "Invalid array expression.");
   context.emitter().Emit(parse_node, InvalidArrayExpression);
-  context.node_stack().Push(parse_node, SemanticsNodeId::BuiltinError);
+  context.node_stack().Push(parse_node, SemIR::NodeId::BuiltinError);
   return true;
 }
 
-}  // namespace Carbon
+}  // namespace Carbon::Check