Are there programming languages that let you return a type that matches the actual object?

With Rust, while it's not strictly based on inheritance, you can use the `Self` keyword in a trait. It allows you to return the specific type that's implementing the trait. Here’s how you might set it up:
```rust
trait Parent {
fn first_method(&self) -> &Self {
self
}
}

struct Child;

impl Parent for Child {}

impl Child {
fn second_method(&self) {
println!("works just fine");
}
}

fn main() {
Child{}.first_method().second_method();
}
```
This way, even though Rust doesn’t have traditional inheritance, you get the functionality you need.

In PHP, you have the `static` return type, which allows a method to return an instance of the class it's called on. So if you call a method on a child class, it will return an instance of that child regardless of where the method is defined. That's useful for your situation!

You can achieve this quite easily in Python! Here's a simple example:
```python
class Parent:
def firstMethod(self):
return self

class Child(Parent):
def secondMethod(self):
pass
```
In this case, `firstMethod` returns the current instance's dynamic type. If you use static type hints, you can even specify `Self` to indicate that the return type matches the calling object. Pretty neat, right?

If you’re into Java, you can use generics to achieve this. By defining a generic type parameter in your `Parent` class, you can return the specific type of the calling class. Here’s an example:
```java
abstract class Parent<Self extends Parent> {
abstract Self getSelf();

Self firstMethod() {
return getSelf();
}
}
class Child extends Parent {
Child getSelf() {
return this;
}
}
```
It’s not the prettiest solution, but it works!