Enable use_self lint

Tighten up the linting by using `use_self` and fix all warnings.

I got claude to do the fixes. It eventually found its way to using

cargo clippy --fix --allow-dirty --allow-staged --workspace \
--all-targets --all-features -- -D clippy::use-self 

FTR this does not enable the lint because for some reason adding this
to the manifest doesn't work.

```rust
[workspace.lints.clippy]
use_self = "warn"
```

I tested this patch using

  `cargo +$(cat ./nightly-version ) clippy -- -D clippy::use-self`

Author: tcharding

src/descriptor/bare.rs

@@ -166,7 +166,7 @@ impl<Pk: FromStrKey> FromTree for Bare<Pk> {
     fn from_tree(root: expression::TreeIterItem) -> Result<Self, Error> {
         let sub = Miniscript::<Pk, BareCtx>::from_tree(root)?;
         BareCtx::top_level_checks(&sub)?;
-        Bare::new(sub)
+        Self::new(sub)
     }
 }
 
@@ -196,7 +196,7 @@ impl<Pk: MiniscriptKey> Pkh<Pk> {
     pub fn new(pk: Pk) -> Result<Self, ScriptContextError> {
         // do the top-level checks
         match BareCtx::check_pk(&pk) {
-            Ok(()) => Ok(Pkh { pk }),
+            Ok(()) => Ok(Self { pk }),
             Err(e) => Err(e),
         }
     }
@@ -353,7 +353,7 @@ impl<Pk: FromStrKey> FromTree for Pkh<Pk> {
         let pk = root
             .verify_terminal_parent("pkh", "public key")
             .map_err(Error::Parse)?;
-        Pkh::new(pk).map_err(Error::ContextError)
+        Self::new(pk).map_err(Error::ContextError)
     }
 }
 

src/descriptor/checksum.rs

@@ -61,13 +61,13 @@ pub enum Error {
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            Error::InvalidCharacter { ch, pos } => {
+            Self::InvalidCharacter { ch, pos } => {
                 write!(f, "invalid character '{}' (position {})", ch, pos)
             }
-            Error::InvalidChecksumLength { actual, expected } => {
+            Self::InvalidChecksumLength { actual, expected } => {
                 write!(f, "invalid checksum (length {}, expected {})", actual, expected)
             }
-            Error::InvalidChecksum { actual, expected } => {
+            Self::InvalidChecksum { actual, expected } => {
                 f.write_str("invalid checksum ")?;
                 for ch in actual {
                     ch.fmt(f)?;
@@ -135,13 +135,13 @@ pub struct Engine {
 }
 
 impl Default for Engine {
-    fn default() -> Engine { Engine::new() }
+    fn default() -> Self { Self::new() }
 }
 
 impl Engine {
     /// Constructs an engine with no input.
     pub fn new() -> Self {
-        Engine { inner: bech32::primitives::checksum::Engine::new(), cls: 0, clscount: 0 }
+        Self { inner: bech32::primitives::checksum::Engine::new(), cls: 0, clscount: 0 }
     }
 
     /// Inputs some data into the checksum engine.