[NPU] Fix Coverity issues (#34632)

### Details:
 - *Fix Coverity issues*

### Tickets:
 - *E#207793*

### AI Assistance:
 - *AI assistance used: no / yes*
- *If yes, summarize how AI was used and what human validation was
performed (build/tests/manual checks).*

Signed-off-by: Bogdan Pereanu <bogdan.pereanu@intel.com>

Author: pereanub

src/plugins/intel_npu/src/backend/src/zero_dynamic_infer_request.cpp

@@ -213,7 +213,9 @@ void ZeroDynamicInferRequest::predict_shapes(std::vector<IDynamicGraph::MemRefTy
             auto& userTensor = get_user_input(i);
             if (userTensor != nullptr) {
                 // If userTensor is set, use userTensor to update memref handle
-                inputPros[i].set(get_tensor_data_ptr(userTensor._ptr), 0, userTensor._ptr);
+                const auto userTensorPtr = userTensor._ptr;
+                OPENVINO_ASSERT(userTensorPtr != nullptr, "Input user tensor pointer is null");
+                inputPros[i].set(get_tensor_data_ptr(userTensorPtr), 0, userTensorPtr);
             } else if (levelZeroTensor != nullptr) {
                 // If userTensor is not set, use levelZeroTensor to update memref handle
                 inputPros[i].set(get_tensor_data_ptr(levelZeroTensor), 0, levelZeroTensor);
@@ -233,7 +235,9 @@ void ZeroDynamicInferRequest::predict_shapes(std::vector<IDynamicGraph::MemRefTy
             auto& userTensor = _userOutputTensors.at(i);
             if (userTensor != nullptr) {
                 // If userTensor is set, use userTensor to update memref handle
-                outputProps[i].set(get_tensor_data_ptr(userTensor._ptr), 0, userTensor._ptr);
+                const auto userTensorPtr = userTensor._ptr;
+                OPENVINO_ASSERT(userTensorPtr != nullptr, "Output user tensor pointer is null");
+                outputProps[i].set(get_tensor_data_ptr(userTensorPtr), 0, userTensorPtr);
             } else if (levelZeroTensor != nullptr) {
                 // If userTensor is not set, use levelZeroTensor to update memref handle
                 outputProps[i].set(get_tensor_data_ptr(levelZeroTensor), 0, levelZeroTensor);

src/plugins/intel_npu/src/backend/src/zero_dynamic_pipeline.cpp

@@ -207,6 +207,9 @@ DynamicPipeline::DynamicPipeline(const Config& config,
 void DynamicPipeline::push() {
     _logger.debug("DynamicPipeline - push() started");
 
+    auto* dynamicGraph = dynamic_cast<IDynamicGraph*>(_graph.get());
+    OPENVINO_ASSERT(dynamicGraph != nullptr, "Failed to cast graph to IDynamicGraph");
+
     if (_init_structs->getCommandQueueDdiTable().version() < ZE_MAKE_VERSION(1, 1) &&
         _config.get<RUN_INFERENCES_SEQUENTIALLY>()) {
         if (_id) {
@@ -246,14 +249,13 @@ void DynamicPipeline::push() {
         // L0 wrapper handle closed command list
         command_lists->resetCommandList();
 
-        dynamic_cast<IDynamicGraph*>(_graph.get())
-            ->execute(_init_structs,
-                      command_lists->getBinding(),
-                      command_lists->getHandles(),
-                      commandQueueHandle,
-                      fence,
-                      event,
-                      nullptr);
+        dynamicGraph->execute(_init_structs,
+                              command_lists->getBinding(),
+                              command_lists->getHandles(),
+                              commandQueueHandle,
+                              fence,
+                              event,
+                              nullptr);
     }
 
     _logger.debug("DynamicPipeline - push() completed");

src/plugins/intel_npu/src/plugin/include/properties.hpp

@@ -75,6 +75,22 @@ class Properties final {
     ov::intel_npu::CompilerType determineCompilerType(const ov::AnyMap& properties) const;
 
 private:
+    struct CopyState {
+        PropertiesType pType;
+        FilteredConfig config;
+        std::shared_ptr<Metrics> metrics;
+        ov::SoPtr<IEngineBackend> backend;
+        Logger logger;
+        ov::intel_npu::CompilerType currentlyUsedCompiler;
+        std::string currentlyUsedPlatform;
+        bool compilerConfigsFilteredByCompiler;
+        std::map<std::string, std::tuple<bool, ov::PropertyMutability, std::function<ov::Any(const Config&)>>>
+            properties;
+        std::vector<ov::PropertyName> supportedProperties;
+    };
+
+    explicit Properties(CopyState&& state);
+
     PropertiesType _pType;
     FilteredConfig _config;
     std::shared_ptr<Metrics> _metrics;
@@ -200,7 +216,7 @@ class Properties final {
                                                                         ov::internal::caching_with_mmap.name(),
                                                                         ov::internal::cache_header_alignment.name()};
 
-    std::mutex _mutex;
+    mutable std::mutex _mutex;
 };
 
 }  // namespace intel_npu

src/plugins/intel_npu/src/plugin/src/properties.cpp

@@ -434,16 +434,31 @@ Properties::Properties(const PropertiesType pType,
 }
 
 Properties::Properties(const Properties& other)
-    : _pType(other._pType),
-      _config(other._config),
-      _metrics(other._metrics),
-      _backend(other._backend),
-      _logger("Properties", _config.get<LOG_LEVEL>()),
-      _currentlyUsedCompiler(other._currentlyUsedCompiler),
-      _currentlyUsedPlatform(other._currentlyUsedPlatform),
-      _compilerConfigsFilteredByCompiler(other._compilerConfigsFilteredByCompiler),
-      _properties(other._properties),
-      _supportedProperties(other._supportedProperties) {}
+    : Properties([&other]() {
+          std::lock_guard<std::mutex> lock(other._mutex);
+          return CopyState{other._pType,
+                           other._config,
+                           other._metrics,
+                           other._backend,
+                           other._logger,
+                           other._currentlyUsedCompiler,
+                           other._currentlyUsedPlatform,
+                           other._compilerConfigsFilteredByCompiler,
+                           other._properties,
+                           other._supportedProperties};
+      }()) {}
+
+Properties::Properties(CopyState&& state)
+    : _pType(state.pType),
+      _config(std::move(state.config)),
+      _metrics(std::move(state.metrics)),
+      _backend(std::move(state.backend)),
+      _logger(std::move(state.logger)),
+      _currentlyUsedCompiler(state.currentlyUsedCompiler),
+      _currentlyUsedPlatform(std::move(state.currentlyUsedPlatform)),
+      _compilerConfigsFilteredByCompiler(state.compilerConfigsFilteredByCompiler),
+      _properties(std::move(state.properties)),
+      _supportedProperties(std::move(state.supportedProperties)) {}
 
 void Properties::registerProperties() {
     // Reset
@@ -912,12 +927,13 @@ ov::Any Properties::getProperty(const std::string& name) {
 }
 
 void Properties::setProperty(const ov::AnyMap& properties) {
+    std::lock_guard<std::mutex> lock(_mutex);
+
     if (properties.count(ov::log::level.name()) != 0) {
         _logger.setLevel(properties.at(ov::log::level.name()).as<ov::log::Level>());
     }
 
     std::unique_ptr<ICompilerAdapter> compiler = nullptr;
-    std::lock_guard<std::mutex> lock(_mutex);
     if (_pType == PropertiesType::PLUGIN) {
         bool propertyIsCompilerConfig = false;
         bool propertyIsRegistered = true;