Implementing a Basic Reference Counter (Rc) in Rust

This challenge asks you to implement a simplified version of Rust's Rc (Reference Counted) smart pointer. Rc allows multiple owners of a single piece of data, automatically managing the lifetime of the data by tracking the number of references. Successfully completing this challenge will give you a deeper understanding of memory management and ownership in Rust.

Problem Description

You are tasked with creating a basic Rc implementation in Rust. This Rc should provide the following functionality:

Data Storage: The Rc should hold a pointer to some data. For simplicity, let's assume the data is a String.
Reference Counting: The Rc should maintain a count of how many Rc instances point to the same data.
Cloning: Cloning an Rc should not clone the underlying data. Instead, it should create a new Rc that points to the same data and increments the reference count.
Dropping: When an Rc instance is dropped, the reference count should be decremented. When the reference count reaches zero, the underlying data should be deallocated (dropped).
Access to Data: Provide a way to access the underlying String data through a shared reference (&String).

Key Requirements:

The implementation must be thread-safe. While this challenge doesn't require explicit testing with multiple threads, the design should be robust enough to handle concurrent access without data races. Using std::sync::Mutex is recommended for the reference count.
Avoid using the standard library's Rc or any other reference-counting smart pointers. The goal is to implement the core logic yourself.
The implementation should handle potential panics gracefully.

Expected Behavior:

Creating an Rc should allocate memory for the String (if it's new) and initialize the reference count to 1.
Cloning an Rc should increment the reference count.
Dropping an Rc should decrement the reference count.
When the reference count reaches 0, the String should be dropped.
Accessing the data through &String should be safe and consistent.

Edge Cases to Consider:

Creating multiple Rc instances pointing to the same data.
Cloning Rc instances multiple times.
Dropping Rc instances in different orders.
Handling potential panics during data deallocation.

Examples

Example 1:

Input:
```rust
let data = Rc::new("Hello, world!".to_string());
let data2 = data.clone();
let data3 = data.clone();
println!("Reference count: {}", Rc::strong_count(&data));
drop(data);
println!("Reference count: {}", Rc::strong_count(&data2));
drop(data2);
drop(data3);

Output:
Reference count: 3
Reference count: 2

Explanation: Initially, the reference count is 1. Cloning creates two more Rc instances, increasing the count to 3. Dropping data decrements the count to 2. Dropping data2 and data3 decrement the count to 0, causing the underlying String to be dropped.

Example 2:

Input:
```rust
let data = Rc::new("Rust is fun!".to_string());
let data2 = data.clone();
let data3 = data.clone();
let data4 = data2.clone();
println!("Reference count: {}", Rc::strong_count(&data));
drop(data);
drop(data2);
println!("Reference count: {}", Rc::strong_count(&data3));
drop(data3);
drop(data4);

Output:
Reference count: 4
Reference count: 2

Explanation: The reference count starts at 1. Cloning creates four Rc instances, increasing the count to 4. Dropping data and data2 reduces the count to 2. Dropping data3 and data4 reduces the count to 0, deallocating the String.

Example 3: (Edge Case - Data already exists)

Input:
```rust
let existing_data = "Some existing data".to_string();
let rc1 = Rc::new(existing_data);
let rc2 = rc1.clone();
println!("Reference count: {}", Rc::strong_count(&rc1));
drop(rc1);
drop(rc2);

Output:
Reference count: 2

Explanation: The Rc takes ownership of the existing String. Cloning increments the reference count. Dropping both Rc instances decrements the count to zero, and the String is deallocated.

Constraints

The implementation must be self-contained within a single Rust file.
The Rc should be able to hold a String.
The strong_count() method must return the current reference count as a usize.
The implementation should not use the standard library's Rc.
The code should compile without warnings.
The implementation should be reasonably efficient (avoid unnecessary allocations or copies).

Notes

Consider using std::sync::Mutex to protect the reference count from data races.
Think carefully about the order of operations when cloning and dropping Rc instances.
The Rc implementation should be generic enough to handle different data types, but for this challenge, focus on String.
Start with a basic implementation and gradually add features and error handling.
Testing is crucial to ensure the correctness of your implementation. Write unit tests to cover various scenarios, including edge cases.