[Transformation] Identity with Result removal transformation workaround (#33175)

### Details:
- Now correctly removes all Identity op from graph even in Result edge
cases where the input node has another Result attached to it
- Unlocks #33166

### Tickets:
 - 177222

### Explaination:
When trying to convert graph:
```
p0 -> I0 -----\
                Multiply ---- Result1
p1 -> I1 -----/           \
                           I2 ----- Result2
```
to
```
p0 ----\
        Multiply ---- Result1
p1 ----/      \
               Result2
```
the issue arises since Multiply outputs 1 tensor: T1, with a name "t1".
Since Identity is a copy operation, then the I2 outputs a new tensor T2
with a name "t2". After removing I2, we need to keep T2, but Multiply
has only one output, T1. The possible solutions were:

- Keep only Multiply’s name "t1": Result2 now would have to have source
tensor renamed to "t1"
- Keep only Identity’s name "t2": Result1 Result2 now would have to have
source tensor renamed to "t2"
- Merge (union) them: both old names still exist, but the tensor’s name
set changed vs the original one
- And the fourth one, replace I2 with another OP. This would generate a
new tensor "t2" from "t1" and if the new OP effectively "does nothing",
the names would be kept

So for now, there is no satisfactory solution. Therefore a workaround
for the NPU plugin is to use another OP: in this PR I decided to replace
I2 edge case with Reshape to have the marginal performance loss, if any.
It won't be eliminated with optimizations for the same reasons why I2
cannot be eliminated.

---------

Co-authored-by: Mikhail Ryzhov <mikhail.ryzhov@intel.com>

Author: PiotrKrzem

src/common/transformations/src/transformations/common_optimizations/nop_elimination.cpp

@@ -31,6 +31,7 @@
 #include "openvino/op/scatter_elements_update.hpp"
 #include "openvino/op/scatter_nd_update.hpp"
 #include "openvino/op/scatter_update.hpp"
+#include "openvino/op/shape_of.hpp"
 #include "openvino/op/slice.hpp"
 #include "openvino/op/split.hpp"
 #include "openvino/op/squeeze.hpp"
@@ -856,7 +857,37 @@ pass::EliminateIdentity::EliminateIdentity() {
         if (!identity) {
             return false;
         }
-        return replace_output_update_name(identity->output(0), identity->input_value(0));
+
+        auto identity_out = identity->output(0);
+        auto replacement = identity->input_value(0);
+
+        if (!replace_output_update_name(identity_out, replacement)) {
+            const auto& consumers = replacement.get_target_inputs();
+            bool replacement_has_result_consumer =
+                std::any_of(consumers.cbegin(), consumers.cend(), [](const Input<Node>& consumer) {
+                    return ov::is_type<op::v0::Result>(consumer.get_node());
+                });
+            // Edge case from ticket 177222
+            // NPU doesn't support Identity, so until then
+            // we use a Reshape as a temp no-op to preserve both tensors
+            if (replacement_has_result_consumer) {
+                auto shape_of = std::make_shared<ov::op::v3::ShapeOf>(replacement, ov::element::i64);
+                auto reshape = std::make_shared<ov::op::v1::Reshape>(replacement, shape_of, false);
+
+                // Preserve the "Identity" friendly name on the new node, so any
+                // output still sees the same logical node name
+                reshape->set_friendly_name(identity->get_friendly_name());
+
+                // Preserve Identity's tensor names on the new output, so externally
+                // visible names for that path remain stable
+                reshape->output(0).get_tensor().set_names(identity_out.get_tensor().get_names());
+
+                ov::copy_runtime_info(identity, {shape_of, reshape});
+                identity_out.replace(reshape);
+            }
+        }
+
+        return true;
     };
 
     auto m = make_shared<pattern::Matcher>(identity_pattern, matcher_name);

src/common/transformations/tests/common_optimizations/nop_elimination.cpp

@@ -2151,3 +2151,45 @@ TEST_F(TransformationTestsF, ScatterNDUpdates15Elimination) {
         model_ref = std::make_shared<ov::Model>(OutputVector{result}, ParameterVector{data, indices, updates});
     }
 }
+
+TEST_F(TransformationTestsF, EliminateIdentity) {
+    {
+        auto p0 = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1});
+        auto p1 = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1});
+
+        auto id0 = std::make_shared<ov::op::v16::Identity>(p0);
+        id0->set_friendly_name("I0");
+
+        auto id1 = std::make_shared<ov::op::v16::Identity>(p1);
+        id1->set_friendly_name("I1");
+
+        auto mul = std::make_shared<ov::op::v1::Multiply>(id0, id1);
+        mul->set_friendly_name("Multiply");
+
+        auto id2 = std::make_shared<ov::op::v16::Identity>(mul);
+        id2->set_friendly_name("I2");
+
+        auto res1 = std::make_shared<ov::op::v0::Result>(mul);
+        auto res2 = std::make_shared<ov::op::v0::Result>(id2);
+
+        model = std::make_shared<ov::Model>(ov::ResultVector{res1, res2}, ov::ParameterVector{p0, p1});
+
+        manager.register_pass<ov::pass::EliminateIdentity>();
+    }
+    {
+        auto p0 = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1});
+        auto p1 = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1});
+
+        auto mul = std::make_shared<ov::op::v1::Multiply>(p0, p1);
+        mul->set_friendly_name("Multiply");
+
+        // Tests the NPU workaround from ticket 177222
+        auto shape_of = std::make_shared<ov::op::v3::ShapeOf>(mul, ov::element::i64);
+        auto reshape = std::make_shared<ov::op::v1::Reshape>(mul, shape_of, false);
+
+        auto res1 = std::make_shared<ov::op::v0::Result>(mul);
+        auto res2 = std::make_shared<ov::op::v0::Result>(reshape);
+
+        model_ref = std::make_shared<ov::Model>(ov::ResultVector{res1, res2}, ov::ParameterVector{p0, p1});
+    }
+}