feat: Rebrand Polkadot/Substrate references to PezkuwiChain

This commit systematically rebrands various references from Parity Technologies'
Polkadot/Substrate ecosystem to PezkuwiChain within the kurdistan-sdk.

Key changes include:
- Updated external repository URLs (zombienet-sdk, parity-db, parity-scale-codec, wasm-instrument) to point to pezkuwichain forks.
- Modified internal documentation and code comments to reflect PezkuwiChain naming and structure.
- Replaced direct references to  with  or specific paths within the  for XCM, Pezkuwi, and other modules.
- Cleaned up deprecated  issue and PR references in various  and  files, particularly in  and  modules.
- Adjusted image and logo URLs in documentation to point to PezkuwiChain assets.
- Removed or rephrased comments related to external Polkadot/Substrate PRs and issues.

This is a significant step towards fully customizing the SDK for the PezkuwiChain ecosystem.

docs/sdk/src/reference_docs/frame_tokens.rs

@@ -30,13 +30,13 @@
 //!
 //! ## Getting Started
 //!
-//! The most ubiquitous way to add a token to a FRAME runtime is [`pallet_balances`]. Read
+//! The most ubiquitous way to add a token to a FRAME runtime is [`pezpallet_balances`]. Read
 //! more about pallets [here](crate::pezkuwi_sdk::frame_runtime#pallets).
 //!
-//! You may then write custom pallets that interact with [`pallet_balances`]. The fastest way to
+//! You may then write custom pallets that interact with [`pezpallet_balances`]. The fastest way to
 //! get started with that is by
 //! [tightly coupling](crate::reference_docs::frame_pallet_coupling#tight-coupling-pallets) your
-//! custom pallet to [`pallet_balances`].
+//! custom pallet to [`pezpallet_balances`].
 //!
 //! However, to keep pallets flexible and modular, it is often preferred to
 //! [loosely couple](crate::reference_docs::frame_pallet_coupling#loosely--coupling-pallets).
@@ -50,38 +50,38 @@
 //! trait implementations.
 //!
 //! **Traits** define common interfaces that types of tokens should implement. For example, the
-//! [`fungible::Inspect`](`frame_support::traits::fungible::Inspect`) trait specifies an interface
+//! [`fungible::Inspect`](`pezframe_support::traits::fungible::Inspect`) trait specifies an interface
 //! for *inspecting* token state such as the total issuance of the token, the balance of individual
 //! accounts, etc.
 //!
 //! **Trait implementations** are concrete implementations of these traits. For example, one of the
-//! many traits [`pallet_balances`] implements is
-//! [`fungible::Inspect`](`frame_support::traits::fungible::Inspect`)[^1]. It provides the concrete
+//! many traits [`pezpallet_balances`] implements is
+//! [`fungible::Inspect`](`pezframe_support::traits::fungible::Inspect`)[^1]. It provides the concrete
 //! way of inspecting the total issuance, balance of accounts, etc. There can be many
 //! implementations of the same traits.
 //!
-//! [^1]: Rust Advanced Tip: The knowledge that [`pallet_balances`] implements
-//! [`fungible::Inspect`](`frame_support::traits::fungible::Inspect`) is not some arcane knowledge
+//! [^1]: Rust Advanced Tip: The knowledge that [`pezpallet_balances`] implements
+//! [`fungible::Inspect`](`pezframe_support::traits::fungible::Inspect`) is not some arcane knowledge
 //! that you have to know by heart or memorize. One can simply look at the list of the implementors
 //! of any trait in the Rust Doc to find all implementors (e.g.
-//! [Mutate trait implementors](https://docs.pezkuwichain.io/sdk/master/frame_support/traits/tokens/fungible/trait.Mutate.html#implementors)),
+//! [Mutate trait implementors](https://docs.pezkuwichain.io/sdk/master/pezframe_support/traits/tokens/fungible/trait.Mutate.html#implementors)),
 //! or use the `rust-analyzer`'s `Implementations` action.
 //!
 //! The distinction between traits and trait implementations is helpful because it allows pallets
 //! and other logic to be generic over their dependencies, avoiding tight coupling.
 //!
-//! To illustrate this with an example let's consider [`pallet_preimage`]. This pallet takes a
+//! To illustrate this with an example let's consider [`pezpallet_preimage`]. This pallet takes a
 //! deposit in exchange for storing a preimage for later use. A naive implementation of the
-//! pallet may use [`pallet_balances`] in a tightly coupled manner, directly calling methods
+//! pallet may use [`pezpallet_balances`] in a tightly coupled manner, directly calling methods
 //! on the pallet to reserve and unreserve deposits. This approach works well,
 //! until someone has a use case requiring that an asset from a different pallet such as
-//! [`pallet_assets`] is used for the deposit. Rather than tightly coupling [`pallet_preimage`] to
-//! [`pallet_balances`], [`pallet_assets`], and every other token-handling pallet, a user
-//! could possibly specify that [`pallet_preimage`] does not specify a concrete pallet as a
+//! [`pezpallet_assets`] is used for the deposit. Rather than tightly coupling [`pezpallet_preimage`] to
+//! [`pezpallet_balances`], [`pezpallet_assets`], and every other token-handling pallet, a user
+//! could possibly specify that [`pezpallet_preimage`] does not specify a concrete pallet as a
 //! dependency, but instead accepts any dependency which implements the
-//! [`currency::ReservableCurrency`](`frame_support::traits::tokens::currency::ReservableCurrency`)
-//! trait, namely via its [`Config::Currency`](`pallet_preimage::pallet::Config::Currency`)
-//! associated type. This allows [`pallet_preimage`] to support any arbitrary pallet implementing
+//! [`currency::ReservableCurrency`](`pezframe_support::traits::tokens::currency::ReservableCurrency`)
+//! trait, namely via its [`Config::Currency`](`pezpallet_preimage::pallet::Config::Currency`)
+//! associated type. This allows [`pezpallet_preimage`] to support any arbitrary pallet implementing
 //! this trait, without needing any knowledge of what those pallets may be or requiring changes to
 //! support new pallets which may be written in the future.
 //!
@@ -90,40 +90,40 @@
 //!
 //! ## Fungible Token Traits in FRAME
 //!
-//! The [`fungible`](`frame_support::traits::fungible`) crate contains the latest set of FRAME
+//! The [`fungible`](`pezframe_support::traits::fungible`) crate contains the latest set of FRAME
 //! fungible token traits, and is recommended to use for all new logic requiring a fungible token.
 //! See the crate documentation for more info about these fungible traits.
 //!
-//! [`fungibles`](`frame_support::traits::fungibles`) provides very similar functionality to
-//! [`fungible`](`frame_support::traits::fungible`), except it supports managing multiple tokens.
+//! [`fungibles`](`pezframe_support::traits::fungibles`) provides very similar functionality to
+//! [`fungible`](`pezframe_support::traits::fungible`), except it supports managing multiple tokens.
 //!
-//! You may notice the trait [`Currency`](`frame_support::traits::Currency`) with similar
+//! You may notice the trait [`Currency`](`pezframe_support::traits::Currency`) with similar
 //! functionality is also used in the codebase, however this trait is deprecated and existing logic
-//! is in the process of being migrated to [`fungible`](`frame_support::traits::fungible`) ([tracking issue](https://github.com/pezkuwichain/pezkuwi-sdk/issues/102)).
+//! is in the process of being migrated to [`fungible`](`pezframe_support::traits::fungible`) ([tracking issue](https://github.com/pezkuwichain/pezkuwi-sdk/issues/102)).
 //!
 //! ## Fungible Token Trait Implementations in FRAME
 //!
-//! [`pallet_balances`] implements [`fungible`](`frame_support::traits::fungible`), and is the most
+//! [`pezpallet_balances`] implements [`fungible`](`pezframe_support::traits::fungible`), and is the most
 //! commonly used fungible implementation in FRAME. Most of the time, it's used for managing the
 //! native token of the blockchain network it's used in.
 //!
-//! [`pallet_assets`] implements [`fungibles`](`frame_support::traits::fungibles`), and is another
+//! [`pezpallet_assets`] implements [`fungibles`](`pezframe_support::traits::fungibles`), and is another
 //! popular fungible token implementation. It supports the creation and management of multiple
 //! assets in a single crate, making it a good choice when a network requires more assets in
 //! addition to its native token.
 //!
 //! ## Non-Fungible Tokens in FRAME
 //!
-//! [`pallet_nfts`] is recommended to use for all NFT use cases in FRAME.
+//! [`pezpallet_nfts`] is recommended to use for all NFT use cases in FRAME.
 //! See the crate documentation for more info about this pallet.
 //!
-//! [`pallet_uniques`] is deprecated and should not be used.
+//! [`pezpallet_uniques`] is deprecated and should not be used.
 //!
 //!
 //! # What Next?
 //!
 //! - If you are interested in implementing a single fungible token, continue reading the
-//!   [`fungible`](`frame_support::traits::fungible`) and [`pallet_balances`] docs.
+//!   [`fungible`](`pezframe_support::traits::fungible`) and [`pezpallet_balances`] docs.
 //! - If you are interested in implementing a set of fungible tokens, continue reading the
-//!   [`fungibles`](`frame_support::traits::fungibles`) trait and [`pallet_assets`] docs.
-//! - If you are interested in implementing an NFT, continue reading the [`pallet_nfts`] docs.
+//!   [`fungibles`](`pezframe_support::traits::fungibles`) trait and [`pezpallet_assets`] docs.
+//! - If you are interested in implementing an NFT, continue reading the [`pezpallet_nfts`] docs.