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_pattern_binding.cpp

@@ -5,20 +5,19 @@
 #include "toolchain/semantics/semantics_context.h"
 #include "toolchain/semantics/semantics_node.h"
 
-namespace Carbon {
+namespace Carbon::Check {
 
-auto SemanticsHandleAddress(SemanticsContext& context,
-                            ParseTree::Node parse_node) -> bool {
+auto HandleAddress(Context& context, ParseTree::Node parse_node) -> bool {
   return context.TODO(parse_node, "HandleAddress");
 }
 
-auto SemanticsHandleGenericPatternBinding(SemanticsContext& context,
-                                          ParseTree::Node parse_node) -> bool {
+auto HandleGenericPatternBinding(Context& context, ParseTree::Node parse_node)
+    -> bool {
   return context.TODO(parse_node, "GenericPatternBinding");
 }
 
-auto SemanticsHandlePatternBinding(SemanticsContext& context,
-                                   ParseTree::Node parse_node) -> bool {
+auto HandlePatternBinding(Context& context, ParseTree::Node parse_node)
+    -> bool {
   auto [type_node, parsed_type_id] =
       context.node_stack().PopExpressionWithParseNode();
   auto cast_type_id = context.ExpressionAsType(type_node, parsed_type_id);
@@ -32,11 +31,11 @@ auto SemanticsHandlePatternBinding(SemanticsContext& context,
   switch (auto context_parse_node_kind = context.parse_tree().node_kind(
               context.node_stack().PeekParseNode())) {
     case ParseNodeKind::VariableIntroducer:
-      context.AddNodeAndPush(parse_node, SemanticsNode::VarStorage::Make(
+      context.AddNodeAndPush(parse_node, SemIR::Node::VarStorage::Make(
                                              name_node, cast_type_id, name_id));
       break;
     case ParseNodeKind::ParameterListStart:
-      context.AddNodeAndPush(parse_node, SemanticsNode::Parameter::Make(
+      context.AddNodeAndPush(parse_node, SemIR::Node::Parameter::Make(
                                              name_node, cast_type_id, name_id));
       break;
     default:
@@ -46,9 +45,8 @@ auto SemanticsHandlePatternBinding(SemanticsContext& context,
   return true;
 }
 
-auto SemanticsHandleTemplate(SemanticsContext& context,
-                             ParseTree::Node parse_node) -> bool {
+auto HandleTemplate(Context& context, ParseTree::Node parse_node) -> bool {
   return context.TODO(parse_node, "HandleTemplate");
 }
 
-}  // namespace Carbon
+}  // namespace Carbon::Check