[Snippets][CPU] Fix LoopManager::get_common_outer_loops indices, remove extra function overloads (#32291)

### Details:
Initialize common loop prefix counter with the first expression’s loop
depth so shared outer loops are preserved when scanning multiple
expressions

### Tickets:
 - N/A

Author: aobolensk

src/common/snippets/include/snippets/lowered/loop_manager.hpp

@@ -65,13 +65,6 @@ class LoopManager {
      * @return vector of outer loop IDs
      */
     static std::vector<size_t> get_outer_expr_loops(const ExpressionPtr& expr, size_t loop_id);
-    /**
-     * @brief Get loop IDs of expression that are common outer (upper) than `loop_id`
-     * @param lhs the first expression
-     * @param rhs the second expression
-     * @return vector of common outer loop IDs
-     */
-    static std::vector<size_t> get_common_outer_loops(const ExpressionPtr& lhs, const ExpressionPtr& rhs);
     /**
      * @brief Get common outer loop IDs of expression set
      * @param exprs vector of expressions

src/common/snippets/src/lowered/loop_manager.cpp

@@ -67,16 +67,6 @@ std::vector<size_t> LoopManager::get_outer_expr_loops(const ExpressionPtr& expr,
     return {loop_ids.cbegin(), it};
 }
 
-std::vector<size_t> LoopManager::get_common_outer_loops(const ExpressionPtr& lhs, const ExpressionPtr& rhs) {
-    const auto& rhs_ids = rhs->get_loop_ids();
-    const auto& lhs_ids = lhs->get_loop_ids();
-    size_t idx = 0;
-    while (idx < std::min(rhs_ids.size(), lhs_ids.size()) && rhs_ids[idx] == lhs_ids[idx]) {
-        idx++;
-    }
-    return {rhs_ids.cbegin(), rhs_ids.cbegin() + idx};
-}
-
 std::vector<size_t> LoopManager::get_common_outer_loops(const std::vector<ExpressionPtr>& exprs) {
     OPENVINO_ASSERT(!exprs.empty(), "Failed to find common outer loops for set of expressions: there no expressions");
 
@@ -89,7 +79,7 @@ std::vector<size_t> LoopManager::get_common_outer_loops(const std::vector<Expres
     };
 
     const auto& first_loop_ids = exprs.front()->get_loop_ids();
-    size_t common_idx = 0;
+    size_t common_idx = first_loop_ids.size();
     for (size_t i = 1; i < exprs.size(); ++i) {
         common_idx = std::min(common_idx, get_first_diff_id_idx(first_loop_ids, exprs[i]->get_loop_ids()));
     }

src/common/snippets/tests/src/lowered/loop_manager.cpp

@@ -0,0 +1,62 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "common_test_utils/ov_test_utils.hpp"
+
+#include <gmock/gmock.h>
+
+#include "snippets/lowered/expression.hpp"
+#include "snippets/lowered/loop_manager.hpp"
+
+namespace ov {
+namespace test {
+namespace snippets {
+namespace {
+
+using ov::snippets::lowered::Expression;
+using ov::snippets::lowered::ExpressionPtr;
+using ov::snippets::lowered::LoopManager;
+using ::testing::ElementsAre;
+using ::testing::IsEmpty;
+
+ExpressionPtr make_expression_with_loops(const std::vector<size_t>& loop_ids) {
+    auto expr = std::make_shared<Expression>();
+    expr->set_loop_ids(loop_ids);
+    return expr;
+}
+
+TEST(LoopManagerTests, SingleExpressionKeepsAllLoops) {
+    auto expr = make_expression_with_loops({1, 2, 3});
+
+    LoopManager manager;
+    const auto loops = manager.get_common_outer_loops({expr});
+
+    EXPECT_THAT(loops, ElementsAre(1, 2, 3));
+}
+
+TEST(LoopManagerTests, MultipleExpressionsShrinkToCommonPrefix) {
+    auto expr0 = make_expression_with_loops({0, 1, 2});
+    auto expr1 = make_expression_with_loops({0, 1, 3});
+    auto expr2 = make_expression_with_loops({0, 4});
+
+    LoopManager manager;
+    const auto loops = manager.get_common_outer_loops({expr0, expr1, expr2});
+
+    EXPECT_THAT(loops, ElementsAre(0));
+}
+
+TEST(LoopManagerTests, ExpressionsWithoutCommonLoops) {
+    auto expr0 = make_expression_with_loops({5, 6});
+    auto expr1 = make_expression_with_loops({7, 8});
+
+    LoopManager manager;
+    const auto loops = manager.get_common_outer_loops({expr0, expr1});
+
+    EXPECT_THAT(loops, IsEmpty());
+}
+
+}  // namespace
+}  // namespace snippets
+}  // namespace test
+}  // namespace ov

src/plugins/intel_cpu/src/transformations/snippets/aarch64/pass/lowered/insert_gemm_copy_buffers.cpp

@@ -40,7 +40,7 @@ bool InsertGemmCopyBuffers::run(LinearIR& linear_ir, LinearIR::constExprIt begin
         BufferExpressionPtr buffer_expr =
             factory->build<ov::intel_cpu::aarch64::RepackedWeightsBufferExpression>(buffer_op, {copy_b_out});
         linear_ir.insert_expr(buffer_expr,
-                              LoopManager::get_common_outer_loops(copy_b_expr, copy_b_consumers.begin()->get_expr()),
+                              LoopManager::get_common_outer_loops({copy_b_expr, copy_b_consumers.begin()->get_expr()}),
                               true,
                               insertion_pos,
                               {copy_b_consumers});

src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/insert_brgemm_copy_buffers.cpp

@@ -51,7 +51,7 @@ bool InsertBrgemmCopyBuffers::run(LinearIR& linear_ir, LinearIR::constExprIt beg
             }
             return linear_ir.insert_expr(
                 buffer_expr,
-                LoopManager::get_common_outer_loops(copy_b_expr, copy_b_consumers.begin()->get_expr()),
+                LoopManager::get_common_outer_loops({copy_b_expr, copy_b_consumers.begin()->get_expr()}),
                 true,
                 insertion_pos,
                 {copy_b_consumers});