Certainly! To generate test cases for the problem "Tree Reconstruction," we need to ensure that we create strongly connected directed graphs with the given constraints. Below is a Python function that serves as a test case generator for this problem.

```python
import random

def generate_strongly_connected_graph(N, M):
    # Initialize the graph with an empty adjacency list
    edges = []
    
    # Ensure the graph is strongly connected by creating a circular path
    nodes = list(range(1, N + 1))
    random.shuffle(nodes)
    
    for i in range(N):
        edges.append((nodes[i], nodes[(i + 1) % N]))
        
    # Add remaining edges randomly
    additional_edges = M - N
    all_possible_edges = [(i, j) for i in range(1, N + 1) for j in range(1, N + 1) if i != j and (i, j) not in edges]
    random.shuffle(all_possible_edges)
    
    for i in range(additional_edges):
        edges.append(all_possible_edges[i])
    
    random.shuffle(edges)
    return edges

def tcgen():
    # Number of nodes N and number of edges M
    N = random.randint(1, 500)
    M = random.randint(0, min(3000, N * (N - 1)))
    
    # Generate strongly connected directed graph
    edges = generate_strongly_connected_graph(N, M)
    
    # Format the output
    testcase = f"{N} {M}\n"
    for s, t in edges:
        testcase += f"{s} {t}\n"
    
    return testcase.strip()

# Example usage:
print(tcgen())
```

### Explanation:

1. **Function `generate_strongly_connected_graph(N, M)`**:
   - Ensures the generated graph is strongly connected by first creating a circular path connecting all nodes.
   - Adds additional edges randomly to reach the desired number of edges `M`.

2. **Function `tcgen()`**:
   - Randomly selects the number of nodes `N` (between 1 and 500 inclusive) and the number of edges `M` (between 0 and 3000 or `N*(N-1)`, whichever is smaller).
   - Utilizes `generate_strongly_connected_graph` to create the edges.
   - Formats the edges into the required input format.

3. **Edge Cases**:
   - The graph is generated to ensure no multi-edges or self-loops.
   - The graph is strongly connected, meeting the problem constraints.

This generator will create random test cases that are valid inputs for the problem "Tree Reconstruction."