Bert's example will work, but it has a few code patterns that should be avoided:

• Depending on Exceptions for expected behavior. The Try-Catch around Folder.GetFolderInfo is not the best way to check if an entry exists. Exceptions are expensive to throw, so if you aren't sure that the item should exist, and you don't require that it exists, you should test for its existence without an Exception. In this case, the best way to do this is to use Entry.TryGetEntryInfo and check for a null return value instead of Folder.GetFolderInfo and expect an exception.
• Using recursion to create the parent folders. This works, but function calls are not free, and in edge cases you can get problems like stack overflow. Instead, you can unwind the recursion with a stack.
• Returning -1 for errors instead of throwing an Exception. You can't tell what went wrong when you return -1, and if later you decide that getting -1 should merit throwing an exception you won't get the full stack trace on your problem. When a method encounters a problem that it cannot recover from, it should throw an exception. If you want to stick with this design pattern, you should name the method "TryGetFolderID" to make it clear that you won't get Exceptions.
• Returning an int instead of a FolderInfo means that there is time in between creating the folder and acquiring a lock on it, which can lead to problems in some cases, and is harder on the server (see Michael Allen's repsonse here).

Again, Cliff's suggestion looks like it will work. That said, here is a rework of the method, addressing some of the above issues in C#:

private static FolderInfo CreateHelper(string path, Session s)
{
    EntryInfo entry = null;
    Stack<string> toCreate = new Stack<string>();
    if (!path.StartsWith("\\"))
        path = "\\" + path;
    
    // This is equivalent to the recursion in the other
    // solution, but with an explicit stack instead of relying
    // on the call stack for state.
    while (entry == null)
    {
        toCreate.Push(path.Split('\\').Last());
        path = path.Substring(0, path.LastIndexOf('\\'));
        if (path == "")
            path = "\\";
        entry = Entry.TryGetEntryInfo(path, s);
    }
    FolderInfo folder = entry as FolderInfo;
    if (folder == null)
    {
        throw new DuplicateObjectException(
            "A parent of the requested folder is a non-folder entry.");
    }

    // Walk back up the stack as if returning from recursive
    // calls.
    FolderInfo parent = null;
    try
    {
        while (toCreate.Count > 0)
        {
            if (parent != null)
                parent.Dispose();
            parent = folder;
            folder = new FolderInfo(s);
            path = toCreate.Pop();
            folder.Create(parent, path, EntryNameOption.None);
        }
    }
    catch (Exception)
    {
        // Guarantee that folder does not leak if an Exception
        // is thrown.
        if (folder != null)
            folder.Dispose();
        throw;
    }
    finally
    {
        // Guarantee that parent does not leak.
        if (parent != null)
            parent.Dispose();
    }

    return folder;
}

public static FolderInfo GetOrCreateFolderInfo(string path, Session s)
{
    if (path == null)
        throw new ArgumentNullException("Path is null.");
    if (s == null)
        throw new ArgumentNullException("Session is null.");
    if (path == "")
        throw new ArgumentException("Path in an empty string.");

    // Will return null instead of throwing an Exception if the
    // entry does not exist.
    EntryInfo entry = Entry.TryGetEntryInfo(path, s);

    if (entry != null)
    {
        FolderInfo folder = entry as FolderInfo;
        if (folder != null)
        {
            return folder;
        }
        else
        {
            throw new DuplicateObjectException("Object already exists");
        }
    }
    else
    {
        return CreateHelper(path, s);
    }
}

To use it, call GetOrCreateFolderInfo with a path and a Session argument. It will make a best effort to create the folder. Note that this will throw Exceptions in cases similar to those when Folder.Create will throw Exceptions; invalid arguments, non-folder object already at the location that it is trying to put a folder. Also, the returned FolderInfo object must be disposed in order to avoid leaks!

The logic is almost identical to Bert's, but it unrolls the recursion, uses a different method to check for existence of the folder, and uses a different method to create the FolderInfo object. Its not perfectly optimized, and the string manipulations especially could use some work for clarity, but it appears to work in the limited test cases that I've tried it in.

EDIT 4/29/14: Added some comments to the code, fixed one or two wording issues in the text. Updated the helper method to fix a possible leak.