Implementing the Drop Trait in Rust: Resource Management

Rust's ownership system and borrowing rules guarantee memory safety without garbage collection. However, sometimes you need to explicitly manage resources like file handles, network connections, or mutexes. The Drop trait allows you to define custom cleanup logic that is automatically executed when a value goes out of scope, ensuring proper resource release and preventing leaks. This challenge asks you to implement a struct that manages a resource and utilizes the Drop trait to release it.

Problem Description

You are tasked with creating a Resource struct that simulates the management of a limited resource (e.g., a file descriptor). The Resource struct should:

1. Hold an integer: This integer represents the resource identifier.
2. Implement the Drop trait: The drop method should print a message indicating that the resource is being released, including the resource identifier.
3. Provide a constructor: A function create_resource(id: i32) that creates and returns a new Resource instance.

The goal is to demonstrate how the Drop trait enables automatic resource cleanup when a Resource instance goes out of scope. The drop method should be called when the Resource instance is no longer needed.

Examples

Example 1:

Input:
```rust
fn main() {
    let resource1 = create_resource(10);
    // resource1 goes out of scope at the end of main
}

Output:

Releasing resource: 10

Explanation: resource1 is created and then goes out of scope at the end of main. The drop method of Resource is automatically called, printing "Releasing resource: 10".

Example 2:

Input:
```rust
fn main() {
    let resource2 = create_resource(25);
    {
        let resource3 = create_resource(5);
        // resource3 goes out of scope at the end of the inner block
    }
    // resource2 goes out of scope at the end of main
}

Output:

Releasing resource: 5
Releasing resource: 25

Explanation: resource2 and resource3 are created. resource3 goes out of scope first, triggering its drop method. Then, resource2 goes out of scope, triggering its drop method.

Example 3: (Edge Case - Multiple Ownership)

Input:
```rust
fn main() {
    let resource4 = create_resource(7);
    let resource5 = resource4; // Ownership transferred to resource5
    // resource4 goes out of scope here, but drop is not called because ownership was moved.
}

Output:

Releasing resource: 7

Explanation: Ownership of the resource is moved from resource4 to resource5. resource4 goes out of scope, but its drop method is not called because it no longer owns the resource. resource5 will trigger the drop when it goes out of scope.

Constraints

• The Resource struct must implement the Drop trait.
• The drop method must print the resource identifier to the console in the format "Releasing resource: [id]".
• The create_resource function must take an i32 as input and return a Resource instance.
• The code must compile and run without errors.
• The drop method should only be called once for each resource.

Notes

• Consider how Rust's ownership system interacts with the Drop trait. A value's drop method is only called when the value goes out of scope and no other references to it exist.
• The drop method is not called explicitly; it's automatically invoked by the Rust compiler.
• This is a simplified example. In real-world scenarios, resource cleanup might involve more complex operations like closing files, releasing locks, or disconnecting from networks.

// Your code here