Some brief additions to hopefully help drive home that dyn Trait is a concrete type

Author: QuineDot

src/dyn-trait-impls.md

@@ -277,6 +277,19 @@ something like the `non_dyn_dispatchable` override attempted above.
 See [issue 51402](https://github.com/rust-lang/rust/issues/51402) for more
 information.
 
+Implementing methods on `dyn Trait` that don't attempt to shadow the
+methods of `Trait` does work, however.
+```rust
+#trait Trait {}
+impl dyn Trait + '_ {
+    fn some_other_method(&self) {}
+}
+
+fn bar(d: &dyn Trait) {
+    d.some_other_method();
+}
+```
+
 ## A niche exception to `dyn Trait: Trait`
 
 Some bounds on traits aren't checked until you try to utilize the trait,

src/dyn-trait-overview.md

@@ -89,10 +89,13 @@ fn bar<T: Trait + ?Sized>(t: &T) {
 }
 ```
 
-
 ### `dyn Trait` is neither a generic nor dynamically typed
 
 Given a concrete lifetime `'a`, `dyn Trait + 'a` is a statically known type.
+The *erased base type* is not statically known, but don't let this confuse
+you: the `dyn Trait` itself is its own distinct type and that type is known
+at compile time.
+
 For example, consider these two function signatures:
 ```rust
 # trait Trait {}
@@ -147,6 +150,11 @@ but deref coercion usually takes care of that case. For many `std` traits,
 the trait is explicitly implemented for `Box<dyn Trait>` as well;
 [we'll also explore what that can look like.](./dyn-trait-box-impl.md))
 
+As a concrete type, you can also implement methods on `dyn Trait`
+(provided `Trait` is local to your crate), and even implement *other*
+traits for `dyn Trait`
+(as we will see in [some of the examples](./dyn-trait-examples.md)).
+
 ### `dyn Trait` is not a supertype
 
 Because you can coerce base types into a `dyn Trait`, it is not uncommon for